ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerInput.js

@@ -0,0 +1,130 @@
+"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 { composeEventHandlers } from "@radix-ui/primitive";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { Slot } from "@radix-ui/react-slot";
+import { forwardRef, useCallback, useEffect, useRef, } from "react";
+import TextareaAutosize from "react-textarea-autosize";
+import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
+import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
+import { useAuiState, useAui } from "@assistant-ui/store";
+import { flushResourcesSync } from "@assistant-ui/tap";
+/**
+ * A text input component for composing messages.
+ *
+ * This component provides a rich text input experience with automatic resizing,
+ * keyboard shortcuts, file paste support, and intelligent focus management.
+ * It integrates with the composer context to manage message state and submission.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Input
+ *   placeholder="Type your message..."
+ *   submitOnEnter={true}
+ *   addAttachmentOnPaste={true}
+ * />
+ * ```
+ */
+export const ComposerPrimitiveInput = forwardRef((_a, forwardedRef) => {
+    var { autoFocus = false, asChild, disabled: disabledProp, onChange, onKeyDown, onPaste, submitOnEnter = true, cancelOnEscape = true, unstable_focusOnRunStart = true, unstable_focusOnScrollToBottom = true, unstable_focusOnThreadSwitched = true, addAttachmentOnPaste = true } = _a, rest = __rest(_a, ["autoFocus", "asChild", "disabled", "onChange", "onKeyDown", "onPaste", "submitOnEnter", "cancelOnEscape", "unstable_focusOnRunStart", "unstable_focusOnScrollToBottom", "unstable_focusOnThreadSwitched", "addAttachmentOnPaste"]);
+    const aui = useAui();
+    const value = useAuiState(({ composer }) => {
+        if (!composer.isEditing)
+            return "";
+        return composer.text;
+    });
+    const Component = asChild ? Slot : TextareaAutosize;
+    const isDisabled = useAuiState(({ thread, composer }) => { var _a; return thread.isDisabled || ((_a = composer.dictation) === null || _a === void 0 ? void 0 : _a.inputDisabled); }) || disabledProp;
+    const textareaRef = useRef(null);
+    const ref = useComposedRefs(forwardedRef, textareaRef);
+    useEscapeKeydown((e) => {
+        var _a;
+        if (!cancelOnEscape)
+            return;
+        // Only handle ESC if it originated from within this input
+        if (!((_a = textareaRef.current) === null || _a === void 0 ? void 0 : _a.contains(e.target)))
+            return;
+        const composer = aui.composer();
+        if (composer.getState().canCancel) {
+            composer.cancel();
+            e.preventDefault();
+        }
+    });
+    const handleKeyPress = (e) => {
+        var _a, _b;
+        if (isDisabled || !submitOnEnter)
+            return;
+        // ignore IME composition events
+        if (e.nativeEvent.isComposing)
+            return;
+        if (e.key === "Enter" && e.shiftKey === false) {
+            const isRunning = aui.thread().getState().isRunning;
+            if (!isRunning) {
+                e.preventDefault();
+                (_b = (_a = textareaRef.current) === null || _a === void 0 ? void 0 : _a.closest("form")) === null || _b === void 0 ? void 0 : _b.requestSubmit();
+            }
+        }
+    };
+    const handlePaste = async (e) => {
+        var _a;
+        if (!addAttachmentOnPaste)
+            return;
+        const threadCapabilities = aui.thread().getState().capabilities;
+        const files = Array.from(((_a = e.clipboardData) === null || _a === void 0 ? void 0 : _a.files) || []);
+        if (threadCapabilities.attachments && files.length > 0) {
+            try {
+                e.preventDefault();
+                await Promise.all(files.map((file) => aui.composer().addAttachment(file)));
+            }
+            catch (error) {
+                console.error("Error adding attachment:", error);
+            }
+        }
+    };
+    const autoFocusEnabled = autoFocus && !isDisabled;
+    const focus = useCallback(() => {
+        const textarea = textareaRef.current;
+        if (!textarea || !autoFocusEnabled)
+            return;
+        textarea.focus({ preventScroll: true });
+        textarea.setSelectionRange(textarea.value.length, textarea.value.length);
+    }, [autoFocusEnabled]);
+    useEffect(() => focus(), [focus]);
+    useOnScrollToBottom(() => {
+        if (aui.composer().getState().type === "thread" &&
+            unstable_focusOnScrollToBottom) {
+            focus();
+        }
+    });
+    useEffect(() => {
+        if (aui.composer().getState().type !== "thread" ||
+            !unstable_focusOnRunStart)
+            return undefined;
+        return aui.on("thread.runStart", focus);
+    }, [unstable_focusOnRunStart, focus, aui]);
+    useEffect(() => {
+        if (aui.composer().getState().type !== "thread" ||
+            !unstable_focusOnThreadSwitched)
+            return undefined;
+        return aui.on("threadListItem.switchedTo", focus);
+    }, [unstable_focusOnThreadSwitched, focus, aui]);
+    return (_jsx(Component, Object.assign({ name: "input", value: value }, rest, { ref: ref, disabled: isDisabled, onChange: composeEventHandlers(onChange, (e) => {
+            if (!aui.composer().getState().isEditing)
+                return;
+            flushResourcesSync(() => {
+                aui.composer().setText(e.target.value);
+            });
+        }), onKeyDown: composeEventHandlers(onKeyDown, handleKeyPress), onPaste: composeEventHandlers(onPaste, handlePaste) })));
+});
+ComposerPrimitiveInput.displayName = "ComposerPrimitive.Input";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerRoot.d.ts

@@ -0,0 +1,28 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ComposerPrimitiveRoot {
+    type Element = ComponentRef<typeof Primitive.form>;
+    /**
+     * Props for the ComposerPrimitive.Root component.
+     * Accepts all standard form element props.
+     */
+    type Props = ComponentPropsWithoutRef<typeof Primitive.form>;
+}
+/**
+ * The root form container for message composition.
+ *
+ * This component provides a form wrapper that handles message submission when the form
+ * is submitted (e.g., via Enter key or submit button). It automatically prevents the
+ * default form submission and triggers the composer's send functionality.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Root>
+ *   <ComposerPrimitive.Input placeholder="Type your message..." />
+ *   <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+ * </ComposerPrimitive.Root>
+ * ```
+ */
+export declare const ComposerPrimitiveRoot: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLFormElement> & import("react").FormHTMLAttributes<HTMLFormElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLFormElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerRoot.js

@@ -0,0 +1,44 @@
+"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 { composeEventHandlers } from "@radix-ui/primitive";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef, } from "react";
+import { useComposerSend } from "./ComposerSend";
+/**
+ * The root form container for message composition.
+ *
+ * This component provides a form wrapper that handles message submission when the form
+ * is submitted (e.g., via Enter key or submit button). It automatically prevents the
+ * default form submission and triggers the composer's send functionality.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Root>
+ *   <ComposerPrimitive.Input placeholder="Type your message..." />
+ *   <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+ * </ComposerPrimitive.Root>
+ * ```
+ */
+export const ComposerPrimitiveRoot = forwardRef((_a, forwardedRef) => {
+    var { onSubmit } = _a, rest = __rest(_a, ["onSubmit"]);
+    const send = useComposerSend();
+    const handleSubmit = (e) => {
+        e.preventDefault();
+        if (!send)
+            return;
+        send();
+    };
+    return (_jsx(Primitive.form, Object.assign({}, rest, { ref: forwardedRef, onSubmit: composeEventHandlers(onSubmit, handleSubmit) })));
+});
+ComposerPrimitiveRoot.displayName = "ComposerPrimitive.Root";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerSend.d.ts

@@ -0,0 +1,27 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+export declare const useComposerSend: () => (() => void) | null;
+export declare namespace ComposerPrimitiveSend {
+    type Element = ActionButtonElement;
+    /**
+     * Props for the ComposerPrimitive.Send component.
+     * Inherits all button element props and action button functionality.
+     */
+    type Props = ActionButtonProps<typeof useComposerSend>;
+}
+/**
+ * A button component that sends the current message in the composer.
+ *
+ * This component automatically handles the send functionality and is disabled
+ * when sending is not available (e.g., when the thread is running, the composer
+ * is empty, or not in editing mode).
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Send>
+ *   Send Message
+ * </ComposerPrimitive.Send>
+ * ```
+ */
+export declare const ComposerPrimitiveSend: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerSend.js

@@ -0,0 +1,29 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+export const useComposerSend = () => {
+    const aui = useAui();
+    const disabled = useAuiState((s) => s.thread.isRunning || !s.composer.isEditing || s.composer.isEmpty);
+    const callback = useCallback(() => {
+        aui.composer().send();
+    }, [aui]);
+    if (disabled)
+        return null;
+    return callback;
+};
+/**
+ * A button component that sends the current message in the composer.
+ *
+ * This component automatically handles the send functionality and is disabled
+ * when sending is not available (e.g., when the thread is running, the composer
+ * is empty, or not in editing mode).
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Send>
+ *   Send Message
+ * </ComposerPrimitive.Send>
+ * ```
+ */
+export const ComposerPrimitiveSend = createActionButton("ComposerPrimitive.Send", useComposerSend);

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerStopDictation.d.ts

@@ -0,0 +1,22 @@
+import type { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useComposerStopDictation: () => (() => void) | null;
+export declare namespace ComposerPrimitiveStopDictation {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useComposerStopDictation>;
+}
+/**
+ * A button that stops the current dictation session.
+ *
+ * Only rendered when dictation is active.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.StopDictation>
+ *   <StopIcon />
+ * </ComposerPrimitive.StopDictation>
+ * ```
+ */
+export declare const ComposerPrimitiveStopDictation: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerStopDictation.js

@@ -0,0 +1,28 @@
+"use client";
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+import { createActionButton } from "../../utils/createActionButton";
+import { useAuiState } from "@assistant-ui/store";
+const useComposerStopDictation = () => {
+    const aui = useAui();
+    const isDictating = useAuiState(({ composer }) => composer.dictation != null);
+    const callback = useCallback(() => {
+        aui.composer().stopDictation();
+    }, [aui]);
+    if (!isDictating)
+        return null;
+    return callback;
+};
+/**
+ * A button that stops the current dictation session.
+ *
+ * Only rendered when dictation is active.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.StopDictation>
+ *   <StopIcon />
+ * </ComposerPrimitive.StopDictation>
+ * ```
+ */
+export const ComposerPrimitiveStopDictation = createActionButton("ComposerPrimitive.StopDictation", useComposerStopDictation);

package/dist/vendor/assistant-ui-react/src/primitives/composer/index.d.ts

@@ -0,0 +1,12 @@
+export { ComposerPrimitiveRoot as Root } from "./ComposerRoot";
+export { ComposerPrimitiveInput as Input } from "./ComposerInput";
+export { ComposerPrimitiveSend as Send } from "./ComposerSend";
+export { ComposerPrimitiveCancel as Cancel } from "./ComposerCancel";
+export { ComposerPrimitiveAddAttachment as AddAttachment } from "./ComposerAddAttachment";
+export { ComposerPrimitiveAttachments as Attachments } from "./ComposerAttachments";
+export { ComposerPrimitiveAttachmentByIndex as AttachmentByIndex } from "./ComposerAttachments";
+export { ComposerPrimitiveAttachmentDropzone as AttachmentDropzone } from "./ComposerAttachmentDropzone";
+export { ComposerPrimitiveDictate as Dictate } from "./ComposerDictate";
+export { ComposerPrimitiveStopDictation as StopDictation } from "./ComposerStopDictation";
+export { ComposerPrimitiveDictationTranscript as DictationTranscript } from "./ComposerDictationTranscript";
+export { ComposerPrimitiveIf as If } from "./ComposerIf";

package/dist/vendor/assistant-ui-react/src/primitives/composer/index.js

@@ -0,0 +1,12 @@
+export { ComposerPrimitiveRoot as Root } from "./ComposerRoot";
+export { ComposerPrimitiveInput as Input } from "./ComposerInput";
+export { ComposerPrimitiveSend as Send } from "./ComposerSend";
+export { ComposerPrimitiveCancel as Cancel } from "./ComposerCancel";
+export { ComposerPrimitiveAddAttachment as AddAttachment } from "./ComposerAddAttachment";
+export { ComposerPrimitiveAttachments as Attachments } from "./ComposerAttachments";
+export { ComposerPrimitiveAttachmentByIndex as AttachmentByIndex } from "./ComposerAttachments";
+export { ComposerPrimitiveAttachmentDropzone as AttachmentDropzone } from "./ComposerAttachmentDropzone";
+export { ComposerPrimitiveDictate as Dictate } from "./ComposerDictate";
+export { ComposerPrimitiveStopDictation as StopDictation } from "./ComposerStopDictation";
+export { ComposerPrimitiveDictationTranscript as DictationTranscript } from "./ComposerDictationTranscript";
+export { ComposerPrimitiveIf as If } from "./ComposerIf";

package/dist/vendor/assistant-ui-react/src/primitives/error/ErrorMessage.d.ts

@@ -0,0 +1,9 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ErrorPrimitiveMessage {
+    type Element = ComponentRef<typeof Primitive.span>;
+    type Props = ComponentPropsWithoutRef<typeof Primitive.span>;
+}
+export declare const ErrorPrimitiveMessage: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/error/ErrorMessage.js

@@ -0,0 +1,30 @@
+"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 { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef } from "react";
+import { useAuiState } from "@assistant-ui/store";
+export const ErrorPrimitiveMessage = forwardRef((_a, forwardRef) => {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    const error = useAuiState(({ message }) => {
+        var _a;
+        return ((_a = message.status) === null || _a === void 0 ? void 0 : _a.type) === "incomplete" &&
+            message.status.reason === "error"
+            ? message.status.error
+            : undefined;
+    });
+    if (error === undefined)
+        return null;
+    return (_jsx(Primitive.span, Object.assign({}, props, { ref: forwardRef, children: children !== null && children !== void 0 ? children : String(error) })));
+});
+ErrorPrimitiveMessage.displayName = "ErrorPrimitive.Message";

package/dist/vendor/assistant-ui-react/src/primitives/error/ErrorRoot.d.ts

@@ -0,0 +1,9 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ErrorPrimitiveRoot {
+    type Element = ComponentRef<typeof Primitive.div>;
+    type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
+}
+export declare const ErrorPrimitiveRoot: 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/error/ErrorRoot.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef } from "react";
+export const ErrorPrimitiveRoot = forwardRef((props, forwardRef) => {
+    return _jsx(Primitive.div, Object.assign({ role: "alert" }, props, { ref: forwardRef }));
+});
+ErrorPrimitiveRoot.displayName = "ErrorPrimitive.Root";

package/dist/vendor/assistant-ui-react/src/primitives/error/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorPrimitiveRoot as Root } from "./ErrorRoot";
+export { ErrorPrimitiveMessage as Message } from "./ErrorMessage";

package/dist/vendor/assistant-ui-react/src/primitives/error/index.js

@@ -0,0 +1,2 @@
+export { ErrorPrimitiveRoot as Root } from "./ErrorRoot";
+export { ErrorPrimitiveMessage as Message } from "./ErrorMessage";

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

@@ -0,0 +1,22 @@
+export * as ActionBarPrimitive from "./actionBar";
+export * as ActionBarMorePrimitive from "./actionBarMore";
+export * as AssistantModalPrimitive from "./assistantModal";
+export * as AttachmentPrimitive from "./attachment";
+export * as BranchPickerPrimitive from "./branchPicker";
+export * as ComposerPrimitive from "./composer";
+export * as MessagePartPrimitive from "./messagePart";
+export * as ErrorPrimitive from "./error";
+export * as MessagePrimitive from "./message";
+export * as ThreadPrimitive from "./thread";
+export * as SuggestionPrimitive from "./suggestion";
+export * as ThreadListPrimitive from "./threadList";
+export * as ThreadListItemPrimitive from "./threadListItem";
+export * as ThreadListItemMorePrimitive from "./threadListItemMore";
+export { useMessagePartText } from "./messagePart/useMessagePartText";
+export { useMessagePartReasoning } from "./messagePart/useMessagePartReasoning";
+export { useMessagePartSource } from "./messagePart/useMessagePartSource";
+export { useMessagePartFile } from "./messagePart/useMessagePartFile";
+export { useMessagePartImage } from "./messagePart/useMessagePartImage";
+export { useMessagePartData } from "./messagePart/useMessagePartData";
+export { useThreadViewportAutoScroll } from "./thread/useThreadViewportAutoScroll";
+export { useScrollLock } from "./reasoning";

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

@@ -0,0 +1,22 @@
+export * as ActionBarPrimitive from "./actionBar";
+export * as ActionBarMorePrimitive from "./actionBarMore";
+export * as AssistantModalPrimitive from "./assistantModal";
+export * as AttachmentPrimitive from "./attachment";
+export * as BranchPickerPrimitive from "./branchPicker";
+export * as ComposerPrimitive from "./composer";
+export * as MessagePartPrimitive from "./messagePart";
+export * as ErrorPrimitive from "./error";
+export * as MessagePrimitive from "./message";
+export * as ThreadPrimitive from "./thread";
+export * as SuggestionPrimitive from "./suggestion";
+export * as ThreadListPrimitive from "./threadList";
+export * as ThreadListItemPrimitive from "./threadListItem";
+export * as ThreadListItemMorePrimitive from "./threadListItemMore";
+export { useMessagePartText } from "./messagePart/useMessagePartText";
+export { useMessagePartReasoning } from "./messagePart/useMessagePartReasoning";
+export { useMessagePartSource } from "./messagePart/useMessagePartSource";
+export { useMessagePartFile } from "./messagePart/useMessagePartFile";
+export { useMessagePartImage } from "./messagePart/useMessagePartImage";
+export { useMessagePartData } from "./messagePart/useMessagePartData";
+export { useThreadViewportAutoScroll } from "./thread/useThreadViewportAutoScroll";
+export { useScrollLock } from "./reasoning";

package/dist/vendor/assistant-ui-react/src/primitives/message/MessageAttachments.d.ts

@@ -0,0 +1,36 @@
+import { ComponentType, type FC } from "react";
+export declare namespace MessagePrimitiveAttachments {
+    type Props = {
+        components: {
+            Image?: ComponentType | undefined;
+            Document?: ComponentType | undefined;
+            File?: ComponentType | undefined;
+            Attachment?: ComponentType | undefined;
+        } | undefined;
+    };
+}
+export declare namespace MessagePrimitiveAttachmentByIndex {
+    type Props = {
+        index: number;
+        components?: MessagePrimitiveAttachments.Props["components"];
+    };
+}
+/**
+ * Renders a single attachment at the specified index within the current message.
+ *
+ * This component provides direct access to render a specific attachment
+ * from the message's attachment list using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <MessagePrimitive.AttachmentByIndex
+ *   index={0}
+ *   components={{
+ *     Image: MyImageAttachment,
+ *     Document: MyDocumentAttachment
+ *   }}
+ * />
+ * ```
+ */
+export declare const MessagePrimitiveAttachmentByIndex: FC<MessagePrimitiveAttachmentByIndex.Props>;
+export declare const MessagePrimitiveAttachments: FC<MessagePrimitiveAttachments.Props>;

package/dist/vendor/assistant-ui-react/src/primitives/message/MessageAttachments.js

@@ -0,0 +1,70 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from "react";
+import { useAuiState } from "@assistant-ui/store";
+import { MessageAttachmentByIndexProvider } from "../../context/providers";
+const getComponent = (components, attachment) => {
+    var _a, _b, _c;
+    const type = attachment.type;
+    switch (type) {
+        case "image":
+            return (_a = components === null || components === void 0 ? void 0 : components.Image) !== null && _a !== void 0 ? _a : components === null || components === void 0 ? void 0 : components.Attachment;
+        case "document":
+            return (_b = components === null || components === void 0 ? void 0 : components.Document) !== null && _b !== void 0 ? _b : components === null || components === void 0 ? void 0 : components.Attachment;
+        case "file":
+            return (_c = components === null || components === void 0 ? void 0 : components.File) !== null && _c !== void 0 ? _c : components === null || components === void 0 ? void 0 : components.Attachment;
+        default:
+            const _exhaustiveCheck = type;
+            throw new Error(`Unknown attachment type: ${_exhaustiveCheck}`);
+    }
+};
+const AttachmentComponent = ({ components }) => {
+    const attachment = useAuiState(({ attachment }) => attachment);
+    if (!attachment)
+        return null;
+    const Component = getComponent(components, attachment);
+    if (!Component)
+        return null;
+    return _jsx(Component, {});
+};
+/**
+ * Renders a single attachment at the specified index within the current message.
+ *
+ * This component provides direct access to render a specific attachment
+ * from the message's attachment list using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <MessagePrimitive.AttachmentByIndex
+ *   index={0}
+ *   components={{
+ *     Image: MyImageAttachment,
+ *     Document: MyDocumentAttachment
+ *   }}
+ * />
+ * ```
+ */
+export const MessagePrimitiveAttachmentByIndex = memo(({ index, components }) => {
+    return (_jsx(MessageAttachmentByIndexProvider, { index: index, children: _jsx(AttachmentComponent, { components: components }) }));
+}, (prev, next) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return prev.index === next.index &&
+        ((_a = prev.components) === null || _a === void 0 ? void 0 : _a.Image) === ((_b = next.components) === null || _b === void 0 ? void 0 : _b.Image) &&
+        ((_c = prev.components) === null || _c === void 0 ? void 0 : _c.Document) === ((_d = next.components) === null || _d === void 0 ? void 0 : _d.Document) &&
+        ((_e = prev.components) === null || _e === void 0 ? void 0 : _e.File) === ((_f = next.components) === null || _f === void 0 ? void 0 : _f.File) &&
+        ((_g = prev.components) === null || _g === void 0 ? void 0 : _g.Attachment) === ((_h = next.components) === null || _h === void 0 ? void 0 : _h.Attachment);
+});
+MessagePrimitiveAttachmentByIndex.displayName =
+    "MessagePrimitive.AttachmentByIndex";
+export const MessagePrimitiveAttachments = ({ components }) => {
+    const attachmentsCount = useAuiState(({ message }) => {
+        if (message.role !== "user")
+            return 0;
+        return message.attachments.length;
+    });
+    const attachmentElements = useMemo(() => {
+        return Array.from({ length: attachmentsCount }, (_, index) => (_jsx(MessagePrimitiveAttachmentByIndex, { index: index, components: components }, index)));
+    }, [attachmentsCount, components]);
+    return attachmentElements;
+};
+MessagePrimitiveAttachments.displayName = "MessagePrimitive.Attachments";

package/dist/vendor/assistant-ui-react/src/primitives/message/MessageError.d.ts

@@ -0,0 +1,2 @@
+import { FC, PropsWithChildren } from "react";
+export declare const MessagePrimitiveError: FC<PropsWithChildren>;

package/dist/vendor/assistant-ui-react/src/primitives/message/MessageError.js

@@ -0,0 +1,11 @@
+"use client";
+import { useAuiState } from "@assistant-ui/store";
+export const MessagePrimitiveError = ({ children }) => {
+    const hasError = useAuiState(({ message }) => {
+        var _a;
+        return ((_a = message.status) === null || _a === void 0 ? void 0 : _a.type) === "incomplete" &&
+            message.status.reason === "error";
+    });
+    return hasError ? children : null;
+};
+MessagePrimitiveError.displayName = "MessagePrimitive.Error";

package/dist/vendor/assistant-ui-react/src/primitives/message/MessageIf.d.ts

@@ -0,0 +1,24 @@
+import type { FC, PropsWithChildren } from "react";
+import type { RequireAtLeastOne } from "../../utils/RequireAtLeastOne";
+type MessageIfFilters = {
+    user: boolean | undefined;
+    assistant: boolean | undefined;
+    system: boolean | undefined;
+    hasBranches: boolean | undefined;
+    copied: boolean | undefined;
+    lastOrHover: boolean | undefined;
+    last: boolean | undefined;
+    speaking: boolean | undefined;
+    hasAttachments: boolean | undefined;
+    hasContent: boolean | undefined;
+    submittedFeedback: "positive" | "negative" | null | undefined;
+};
+type UseMessageIfProps = RequireAtLeastOne<MessageIfFilters>;
+export declare namespace MessagePrimitiveIf {
+    type Props = PropsWithChildren<UseMessageIfProps>;
+}
+/**
+ * @deprecated Use `<AuiIf condition={({ message }) => ...} />` instead.
+ */
+export declare const MessagePrimitiveIf: FC<MessagePrimitiveIf.Props>;
+export {};