ikoncomponents 1.6.3 → 1.6.5

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

@@ -0,0 +1,64 @@
+"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 { useAuiState } from "@assistant-ui/store";
+const useMessageIf = (props) => {
+    return useAuiState(({ message }) => {
+        var _a, _b;
+        const { role, attachments, parts, branchCount, isLast, speech, isCopied, isHovering, } = message;
+        if (props.hasBranches === true && branchCount < 2)
+            return false;
+        if (props.user && role !== "user")
+            return false;
+        if (props.assistant && role !== "assistant")
+            return false;
+        if (props.system && role !== "system")
+            return false;
+        if (props.lastOrHover === true && !isHovering && !isLast)
+            return false;
+        if (props.last !== undefined && props.last !== isLast)
+            return false;
+        if (props.copied === true && !isCopied)
+            return false;
+        if (props.copied === false && isCopied)
+            return false;
+        if (props.speaking === true && speech == null)
+            return false;
+        if (props.speaking === false && speech != null)
+            return false;
+        if (props.hasAttachments === true &&
+            (role !== "user" || !(attachments === null || attachments === void 0 ? void 0 : attachments.length)))
+            return false;
+        if (props.hasAttachments === false &&
+            role === "user" &&
+            !!(attachments === null || attachments === void 0 ? void 0 : attachments.length))
+            return false;
+        if (props.hasContent === true && parts.length === 0)
+            return false;
+        if (props.hasContent === false && parts.length > 0)
+            return false;
+        if (props.submittedFeedback !== undefined &&
+            ((_b = (_a = message.metadata.submittedFeedback) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : null) !==
+                props.submittedFeedback)
+            return false;
+        return true;
+    });
+};
+/**
+ * @deprecated Use `<AuiIf condition={({ message }) => ...} />` instead.
+ */
+export const MessagePrimitiveIf = (_a) => {
+    var { children } = _a, query = __rest(_a, ["children"]);
+    const result = useMessageIf(query);
+    return result ? children : null;
+};
+MessagePrimitiveIf.displayName = "MessagePrimitive.If";

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

@@ -0,0 +1,180 @@
+import { type ComponentType, type FC, PropsWithChildren } from "react";
+import type { Unstable_AudioMessagePartComponent, EmptyMessagePartComponent, TextMessagePartComponent, ImageMessagePartComponent, SourceMessagePartComponent, ToolCallMessagePartComponent, ToolCallMessagePartProps, FileMessagePartComponent, ReasoningMessagePartComponent, ReasoningGroupComponent } from "../../types/MessagePartComponentTypes";
+export declare namespace MessagePrimitiveParts {
+    type Props = {
+        /**
+         * Component configuration for rendering different types of message content.
+         *
+         * You can provide custom components for each content type (text, image, file, etc.)
+         * and configure tool rendering behavior. If not provided, default components will be used.
+         */
+        components?: {
+            /** Component for rendering empty messages */
+            Empty?: EmptyMessagePartComponent | undefined;
+            /** Component for rendering text content */
+            Text?: TextMessagePartComponent | undefined;
+            /** Component for rendering reasoning content (typically hidden) */
+            Reasoning?: ReasoningMessagePartComponent | undefined;
+            /** Component for rendering source content */
+            Source?: SourceMessagePartComponent | undefined;
+            /** Component for rendering image content */
+            Image?: ImageMessagePartComponent | undefined;
+            /** Component for rendering file content */
+            File?: FileMessagePartComponent | undefined;
+            /** Component for rendering audio content (experimental) */
+            Unstable_Audio?: Unstable_AudioMessagePartComponent | undefined;
+            /** Configuration for tool call rendering */
+            tools?: {
+                /** Map of tool names to their specific components */
+                by_name?: Record<string, ToolCallMessagePartComponent | undefined> | undefined;
+                /** Fallback component for unregistered tools */
+                Fallback?: ComponentType<ToolCallMessagePartProps> | undefined;
+            } | {
+                /** Override component that handles all tool calls */
+                Override: ComponentType<ToolCallMessagePartProps>;
+            } | undefined;
+            /**
+             * Component for rendering grouped consecutive tool calls.
+             *
+             * When provided, this component will automatically wrap consecutive tool-call
+             * message parts, allowing you to create collapsible sections, custom styling,
+             * or other grouped presentations for multiple tool calls.
+             *
+             * The component receives:
+             * - `startIndex`: The index of the first tool call in the group
+             * - `endIndex`: The index of the last tool call in the group
+             * - `children`: The rendered tool call components
+             *
+             * @example
+             * ```tsx
+             * // Collapsible tool group
+             * ToolGroup: ({ startIndex, endIndex, children }) => (
+             *   <details className="tool-group">
+             *     <summary>
+             *       {endIndex - startIndex + 1} tool calls
+             *     </summary>
+             *     <div className="tool-group-content">
+             *       {children}
+             *     </div>
+             *   </details>
+             * )
+             * ```
+             *
+             * @example
+             * ```tsx
+             * // Custom styled tool group with header
+             * ToolGroup: ({ startIndex, endIndex, children }) => (
+             *   <div className="border rounded-lg p-4 my-2">
+             *     <div className="text-sm text-gray-600 mb-2">
+             *       Tool execution #{startIndex + 1}-{endIndex + 1}
+             *     </div>
+             *     <div className="space-y-2">
+             *       {children}
+             *     </div>
+             *   </div>
+             * )
+             * ```
+             *
+             * @param startIndex - Index of the first tool call in the group
+             * @param endIndex - Index of the last tool call in the group
+             * @param children - Rendered tool call components to display within the group
+             *
+             * @deprecated This feature is still experimental and subject to change.
+             */
+            ToolGroup?: ComponentType<PropsWithChildren<{
+                startIndex: number;
+                endIndex: number;
+            }>>;
+            /**
+             * Component for rendering grouped reasoning parts.
+             *
+             * When provided, this component will automatically wrap reasoning message parts
+             * (one or more consecutive) in a group container. Each reasoning part inside
+             * renders its own text independently - no text merging occurs.
+             *
+             * The component receives:
+             * - `startIndex`: The index of the first reasoning part in the group
+             * - `endIndex`: The index of the last reasoning part in the group
+             * - `children`: The rendered Reasoning components (one per part)
+             *
+             * @example
+             * ```tsx
+             * // Collapsible reasoning group
+             * ReasoningGroup: ({ children }) => (
+             *   <details className="reasoning-group">
+             *     <summary>Reasoning</summary>
+             *     <div className="reasoning-content">
+             *       {children}
+             *     </div>
+             *   </details>
+             * )
+             * ```
+             *
+             * @param startIndex - Index of the first reasoning part in the group
+             * @param endIndex - Index of the last reasoning part in the group
+             * @param children - Rendered reasoning part components
+             */
+            ReasoningGroup?: ReasoningGroupComponent;
+        } | undefined;
+        /**
+         * When enabled, shows the Empty component if the last part in the message
+         * is anything other than Text or Reasoning.
+         *
+         * This can be useful to ensure there's always a visible element at the end
+         * of messages that end with non-text content like tool calls or images.
+         *
+         * @experimental This API is experimental and may change in future versions.
+         * @default true
+         */
+        unstable_showEmptyOnNonTextEnd?: boolean | undefined;
+    };
+}
+export declare namespace MessagePrimitivePartByIndex {
+    type Props = {
+        index: number;
+        components: MessagePrimitiveParts.Props["components"];
+    };
+}
+/**
+ * Renders a single message part at the specified index.
+ *
+ * This component provides direct access to render a specific message part
+ * within the current message context, using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <MessagePrimitive.PartByIndex
+ *   index={0}
+ *   components={{
+ *     Text: MyTextComponent,
+ *     Image: MyImageComponent
+ *   }}
+ * />
+ * ```
+ */
+export declare const MessagePrimitivePartByIndex: FC<MessagePrimitivePartByIndex.Props>;
+/**
+ * Renders the parts of a message with support for multiple content types.
+ *
+ * This component automatically handles different types of message content including
+ * text, images, files, tool calls, and more. It provides a flexible component
+ * system for customizing how each content type is rendered.
+ *
+ * @example
+ * ```tsx
+ * <MessagePrimitive.Parts
+ *   components={{
+ *     Text: ({ text }) => <p className="message-text">{text}</p>,
+ *     Image: ({ image }) => <img src={image} alt="Message image" />,
+ *     tools: {
+ *       by_name: {
+ *         calculator: CalculatorTool,
+ *         weather: WeatherTool,
+ *       },
+ *       Fallback: DefaultToolComponent
+ *     }
+ *   }}
+ * />
+ * ```
+ */
+export declare const MessagePrimitiveParts: FC<MessagePrimitiveParts.Props>;

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

@@ -0,0 +1,268 @@
+"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, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useMemo, } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+import { PartByIndexProvider, TextMessagePartProvider, } from "../../context/providers";
+import { MessagePartPrimitiveText } from "../messagePart/MessagePartText";
+import { MessagePartPrimitiveImage } from "../messagePart/MessagePartImage";
+import { MessagePartPrimitiveInProgress } from "../messagePart/MessagePartInProgress";
+import { useShallow } from "zustand/shallow";
+/**
+ * Creates a group state manager for a specific part type.
+ * Returns functions to start, end, and finalize groups.
+ */
+const createGroupState = (groupType) => {
+    let start = -1;
+    return {
+        startGroup: (index) => {
+            if (start === -1) {
+                start = index;
+            }
+        },
+        endGroup: (endIndex, ranges) => {
+            if (start !== -1) {
+                ranges.push({
+                    type: groupType,
+                    startIndex: start,
+                    endIndex,
+                });
+                start = -1;
+            }
+        },
+        finalize: (endIndex, ranges) => {
+            if (start !== -1) {
+                ranges.push({
+                    type: groupType,
+                    startIndex: start,
+                    endIndex,
+                });
+            }
+        },
+    };
+};
+/**
+ * Groups consecutive tool-call and reasoning message parts into ranges.
+ * Always groups tool calls and reasoning parts, even if there's only one.
+ */
+const groupMessageParts = (messageTypes) => {
+    const ranges = [];
+    const toolGroup = createGroupState("toolGroup");
+    const reasoningGroup = createGroupState("reasoningGroup");
+    for (let i = 0; i < messageTypes.length; i++) {
+        const type = messageTypes[i];
+        if (type === "tool-call") {
+            reasoningGroup.endGroup(i - 1, ranges);
+            toolGroup.startGroup(i);
+        }
+        else if (type === "reasoning") {
+            toolGroup.endGroup(i - 1, ranges);
+            reasoningGroup.startGroup(i);
+        }
+        else {
+            toolGroup.endGroup(i - 1, ranges);
+            reasoningGroup.endGroup(i - 1, ranges);
+            ranges.push({ type: "single", index: i });
+        }
+    }
+    toolGroup.finalize(messageTypes.length - 1, ranges);
+    reasoningGroup.finalize(messageTypes.length - 1, ranges);
+    return ranges;
+};
+const useMessagePartsGroups = () => {
+    const messageTypes = useAuiState(useShallow((s) => s.message.parts.map((c) => c.type)));
+    return useMemo(() => {
+        if (messageTypes.length === 0) {
+            return [];
+        }
+        return groupMessageParts(messageTypes);
+    }, [messageTypes]);
+};
+const ToolUIDisplay = (_a) => {
+    var { Fallback } = _a, props = __rest(_a, ["Fallback"]);
+    const Render = useAuiState(({ tools }) => {
+        var _a, _b;
+        const Render = (_a = tools.tools[props.toolName]) !== null && _a !== void 0 ? _a : Fallback;
+        if (Array.isArray(Render))
+            return (_b = Render[0]) !== null && _b !== void 0 ? _b : Fallback;
+        return Render;
+    });
+    if (!Render)
+        return null;
+    return _jsx(Render, Object.assign({}, props));
+};
+const defaultComponents = {
+    Text: () => (_jsxs("p", { style: { whiteSpace: "pre-line" }, children: [_jsx(MessagePartPrimitiveText, {}), _jsx(MessagePartPrimitiveInProgress, { children: _jsx("span", { style: { fontFamily: "revert" }, children: " \u25CF" }) })] })),
+    Reasoning: () => null,
+    Source: () => null,
+    Image: () => _jsx(MessagePartPrimitiveImage, {}),
+    File: () => null,
+    Unstable_Audio: () => null,
+    ToolGroup: ({ children }) => children,
+    ReasoningGroup: ({ children }) => children,
+};
+const MessagePartComponent = ({ components: { Text = defaultComponents.Text, Reasoning = defaultComponents.Reasoning, Image = defaultComponents.Image, Source = defaultComponents.Source, File = defaultComponents.File, Unstable_Audio: Audio = defaultComponents.Unstable_Audio, tools = {}, } = {}, }) => {
+    var _a, _b, _c;
+    const aui = useAui();
+    const part = useAuiState(({ part }) => part);
+    const type = part.type;
+    if (type === "tool-call") {
+        const addResult = aui.part().addToolResult;
+        const resume = aui.part().resumeToolCall;
+        if ("Override" in tools)
+            return _jsx(tools.Override, Object.assign({}, part, { addResult: addResult, resume: resume }));
+        const Tool = (_b = (_a = tools.by_name) === null || _a === void 0 ? void 0 : _a[part.toolName]) !== null && _b !== void 0 ? _b : tools.Fallback;
+        return (_jsx(ToolUIDisplay, Object.assign({}, part, { Fallback: Tool, addResult: addResult, resume: resume })));
+    }
+    if (((_c = part.status) === null || _c === void 0 ? void 0 : _c.type) === "requires-action")
+        throw new Error("Encountered unexpected requires-action status");
+    switch (type) {
+        case "text":
+            return _jsx(Text, Object.assign({}, part));
+        case "reasoning":
+            return _jsx(Reasoning, Object.assign({}, part));
+        case "source":
+            return _jsx(Source, Object.assign({}, part));
+        case "image":
+            return _jsx(Image, Object.assign({}, part));
+        case "file":
+            return _jsx(File, Object.assign({}, part));
+        case "audio":
+            return _jsx(Audio, Object.assign({}, part));
+        case "data":
+            return null;
+        default:
+            const unhandledType = type;
+            throw new Error(`Unknown message part type: ${unhandledType}`);
+    }
+};
+/**
+ * Renders a single message part at the specified index.
+ *
+ * This component provides direct access to render a specific message part
+ * within the current message context, using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <MessagePrimitive.PartByIndex
+ *   index={0}
+ *   components={{
+ *     Text: MyTextComponent,
+ *     Image: MyImageComponent
+ *   }}
+ * />
+ * ```
+ */
+export const MessagePrimitivePartByIndex = memo(({ index, components }) => {
+    return (_jsx(PartByIndexProvider, { index: index, children: _jsx(MessagePartComponent, { components: components }) }));
+}, (prev, next) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    return prev.index === next.index &&
+        ((_a = prev.components) === null || _a === void 0 ? void 0 : _a.Text) === ((_b = next.components) === null || _b === void 0 ? void 0 : _b.Text) &&
+        ((_c = prev.components) === null || _c === void 0 ? void 0 : _c.Reasoning) === ((_d = next.components) === null || _d === void 0 ? void 0 : _d.Reasoning) &&
+        ((_e = prev.components) === null || _e === void 0 ? void 0 : _e.Source) === ((_f = next.components) === null || _f === void 0 ? void 0 : _f.Source) &&
+        ((_g = prev.components) === null || _g === void 0 ? void 0 : _g.Image) === ((_h = next.components) === null || _h === void 0 ? void 0 : _h.Image) &&
+        ((_j = prev.components) === null || _j === void 0 ? void 0 : _j.File) === ((_k = next.components) === null || _k === void 0 ? void 0 : _k.File) &&
+        ((_l = prev.components) === null || _l === void 0 ? void 0 : _l.Unstable_Audio) === ((_m = next.components) === null || _m === void 0 ? void 0 : _m.Unstable_Audio) &&
+        ((_o = prev.components) === null || _o === void 0 ? void 0 : _o.tools) === ((_p = next.components) === null || _p === void 0 ? void 0 : _p.tools) &&
+        ((_q = prev.components) === null || _q === void 0 ? void 0 : _q.ToolGroup) === ((_r = next.components) === null || _r === void 0 ? void 0 : _r.ToolGroup) &&
+        ((_s = prev.components) === null || _s === void 0 ? void 0 : _s.ReasoningGroup) === ((_t = next.components) === null || _t === void 0 ? void 0 : _t.ReasoningGroup);
+});
+MessagePrimitivePartByIndex.displayName = "MessagePrimitive.PartByIndex";
+const EmptyPartFallback = ({ status, component: Component }) => {
+    return (_jsx(TextMessagePartProvider, { text: "", isRunning: status.type === "running", children: _jsx(Component, { type: "text", text: "", status: status }) }));
+};
+const COMPLETE_STATUS = Object.freeze({
+    type: "complete",
+});
+const EmptyPartsImpl = ({ components }) => {
+    var _a;
+    const status = useAuiState((s) => { var _a; return ((_a = s.message.status) !== null && _a !== void 0 ? _a : COMPLETE_STATUS); });
+    if (components === null || components === void 0 ? void 0 : components.Empty)
+        return _jsx(components.Empty, { status: status });
+    return (_jsx(EmptyPartFallback, { status: status, component: (_a = components === null || components === void 0 ? void 0 : components.Text) !== null && _a !== void 0 ? _a : defaultComponents.Text }));
+};
+const EmptyParts = memo(EmptyPartsImpl, (prev, next) => {
+    var _a, _b, _c, _d;
+    return ((_a = prev.components) === null || _a === void 0 ? void 0 : _a.Empty) === ((_b = next.components) === null || _b === void 0 ? void 0 : _b.Empty) &&
+        ((_c = prev.components) === null || _c === void 0 ? void 0 : _c.Text) === ((_d = next.components) === null || _d === void 0 ? void 0 : _d.Text);
+});
+const ConditionalEmptyImpl = ({ components, enabled }) => {
+    const shouldShowEmpty = useAuiState(({ message }) => {
+        if (!enabled)
+            return false;
+        if (message.parts.length === 0)
+            return false;
+        const lastPart = message.parts[message.parts.length - 1];
+        return (lastPart === null || lastPart === void 0 ? void 0 : lastPart.type) !== "text" && (lastPart === null || lastPart === void 0 ? void 0 : lastPart.type) !== "reasoning";
+    });
+    if (!shouldShowEmpty)
+        return null;
+    return _jsx(EmptyParts, { components: components });
+};
+const ConditionalEmpty = memo(ConditionalEmptyImpl, (prev, next) => {
+    var _a, _b, _c, _d;
+    return prev.enabled === next.enabled &&
+        ((_a = prev.components) === null || _a === void 0 ? void 0 : _a.Empty) === ((_b = next.components) === null || _b === void 0 ? void 0 : _b.Empty) &&
+        ((_c = prev.components) === null || _c === void 0 ? void 0 : _c.Text) === ((_d = next.components) === null || _d === void 0 ? void 0 : _d.Text);
+});
+/**
+ * Renders the parts of a message with support for multiple content types.
+ *
+ * This component automatically handles different types of message content including
+ * text, images, files, tool calls, and more. It provides a flexible component
+ * system for customizing how each content type is rendered.
+ *
+ * @example
+ * ```tsx
+ * <MessagePrimitive.Parts
+ *   components={{
+ *     Text: ({ text }) => <p className="message-text">{text}</p>,
+ *     Image: ({ image }) => <img src={image} alt="Message image" />,
+ *     tools: {
+ *       by_name: {
+ *         calculator: CalculatorTool,
+ *         weather: WeatherTool,
+ *       },
+ *       Fallback: DefaultToolComponent
+ *     }
+ *   }}
+ * />
+ * ```
+ */
+export const MessagePrimitiveParts = ({ components, unstable_showEmptyOnNonTextEnd = true, }) => {
+    const contentLength = useAuiState(({ message }) => message.parts.length);
+    const messageRanges = useMessagePartsGroups();
+    const partsElements = useMemo(() => {
+        if (contentLength === 0) {
+            return _jsx(EmptyParts, { components: components });
+        }
+        return messageRanges.map((range) => {
+            var _a, _b;
+            if (range.type === "single") {
+                return (_jsx(MessagePrimitivePartByIndex, { index: range.index, components: components }, range.index));
+            }
+            else if (range.type === "toolGroup") {
+                const ToolGroupComponent = (_a = components === null || components === void 0 ? void 0 : components.ToolGroup) !== null && _a !== void 0 ? _a : defaultComponents.ToolGroup;
+                return (_jsx(ToolGroupComponent, { startIndex: range.startIndex, endIndex: range.endIndex, children: Array.from({ length: range.endIndex - range.startIndex + 1 }, (_, i) => (_jsx(MessagePrimitivePartByIndex, { index: range.startIndex + i, components: components }, i))) }, `tool-${range.startIndex}`));
+            }
+            else {
+                // reasoningGroup
+                const ReasoningGroupComponent = (_b = components === null || components === void 0 ? void 0 : components.ReasoningGroup) !== null && _b !== void 0 ? _b : defaultComponents.ReasoningGroup;
+                return (_jsx(ReasoningGroupComponent, { startIndex: range.startIndex, endIndex: range.endIndex, children: Array.from({ length: range.endIndex - range.startIndex + 1 }, (_, i) => (_jsx(MessagePrimitivePartByIndex, { index: range.startIndex + i, components: components }, i))) }, `reasoning-${range.startIndex}`));
+            }
+        });
+    }, [messageRanges, components, contentLength]);
+    return (_jsxs(_Fragment, { children: [partsElements, _jsx(ConditionalEmpty, { components: components, enabled: unstable_showEmptyOnNonTextEnd })] }));
+};
+MessagePrimitiveParts.displayName = "MessagePrimitive.Parts";