ikoncomponents 1.6.3 → 1.6.5

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

@@ -0,0 +1,82 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Slot } from "@radix-ui/react-slot";
+import { createContext, useCallback, useContext, } from "react";
+import { useThreadViewportStore } from "../../context/react/ThreadViewportContext";
+import { useAuiState } from "@assistant-ui/store";
+import { useManagedRef } from "../../utils/hooks/useManagedRef";
+const SlackNestingContext = createContext(false);
+const parseCssLength = (value, element) => {
+    const match = value.match(/^([\d.]+)(em|px|rem)$/);
+    if (!match)
+        return 0;
+    const num = parseFloat(match[1]);
+    const unit = match[2];
+    if (unit === "px")
+        return num;
+    if (unit === "em") {
+        const fontSize = parseFloat(getComputedStyle(element).fontSize) || 16;
+        return num * fontSize;
+    }
+    if (unit === "rem") {
+        const rootFontSize = parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
+        return num * rootFontSize;
+    }
+    return 0;
+};
+/**
+ * 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 const ThreadPrimitiveViewportSlack = ({ children, fillClampThreshold = "10em", fillClampOffset = "6em", }) => {
+    const shouldApplySlack = useAuiState(
+    // only add slack to the last assistant message following a user message (valid turn)
+    ({ thread, message }) => {
+        var _a;
+        return message.isLast &&
+            message.role === "assistant" &&
+            message.index >= 1 &&
+            ((_a = thread.messages.at(message.index - 1)) === null || _a === void 0 ? void 0 : _a.role) === "user";
+    });
+    const threadViewportStore = useThreadViewportStore({ optional: true });
+    const isNested = useContext(SlackNestingContext);
+    const callback = useCallback((el) => {
+        if (!threadViewportStore || isNested)
+            return;
+        const updateMinHeight = () => {
+            const state = threadViewportStore.getState();
+            if (state.turnAnchor === "top" && shouldApplySlack) {
+                const { viewport, inset, userMessage } = state.height;
+                const threshold = parseCssLength(fillClampThreshold, el);
+                const offset = parseCssLength(fillClampOffset, el);
+                const clampAdjustment = userMessage <= threshold ? userMessage : offset;
+                const minHeight = Math.max(0, viewport - inset - clampAdjustment);
+                el.style.minHeight = `${minHeight}px`;
+                el.style.flexShrink = "0";
+                el.style.transition = "min-height 0s";
+            }
+            else {
+                el.style.minHeight = "";
+                el.style.flexShrink = "";
+                el.style.transition = "";
+            }
+        };
+        updateMinHeight();
+        return threadViewportStore.subscribe(updateMinHeight);
+    }, [
+        threadViewportStore,
+        shouldApplySlack,
+        isNested,
+        fillClampThreshold,
+        fillClampOffset,
+    ]);
+    const ref = useManagedRef(callback);
+    return (_jsx(SlackNestingContext.Provider, { value: true, children: _jsx(Slot, { ref: ref, children: children }) }));
+};
+ThreadPrimitiveViewportSlack.displayName = "ThreadPrimitive.ViewportSlack";

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

@@ -0,0 +1,12 @@
+export { ThreadPrimitiveRoot as Root } from "./ThreadRoot";
+export { ThreadPrimitiveEmpty as Empty } from "./ThreadEmpty";
+export { ThreadPrimitiveIf as If } from "./ThreadIf";
+export { ThreadPrimitiveViewport as Viewport } from "./ThreadViewport";
+export { ThreadPrimitiveViewportProvider as ViewportProvider } from "../../context/providers/ThreadViewportProvider";
+export { ThreadPrimitiveViewportFooter as ViewportFooter } from "./ThreadViewportFooter";
+export { ThreadPrimitiveViewportSlack as ViewportSlack } from "./ThreadViewportSlack";
+export { ThreadPrimitiveMessages as Messages } from "./ThreadMessages";
+export { ThreadPrimitiveMessageByIndex as MessageByIndex } from "./ThreadMessages";
+export { ThreadPrimitiveScrollToBottom as ScrollToBottom } from "./ThreadScrollToBottom";
+export { ThreadPrimitiveSuggestion as Suggestion } from "./ThreadSuggestion";
+export { ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, } from "./ThreadSuggestions";

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

@@ -0,0 +1,12 @@
+export { ThreadPrimitiveRoot as Root } from "./ThreadRoot";
+export { ThreadPrimitiveEmpty as Empty } from "./ThreadEmpty";
+export { ThreadPrimitiveIf as If } from "./ThreadIf";
+export { ThreadPrimitiveViewport as Viewport } from "./ThreadViewport";
+export { ThreadPrimitiveViewportProvider as ViewportProvider } from "../../context/providers/ThreadViewportProvider";
+export { ThreadPrimitiveViewportFooter as ViewportFooter } from "./ThreadViewportFooter";
+export { ThreadPrimitiveViewportSlack as ViewportSlack } from "./ThreadViewportSlack";
+export { ThreadPrimitiveMessages as Messages } from "./ThreadMessages";
+export { ThreadPrimitiveMessageByIndex as MessageByIndex } from "./ThreadMessages";
+export { ThreadPrimitiveScrollToBottom as ScrollToBottom } from "./ThreadScrollToBottom";
+export { ThreadPrimitiveSuggestion as Suggestion } from "./ThreadSuggestion";
+export { ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, } from "./ThreadSuggestions";

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

@@ -0,0 +1,31 @@
+import { type RefCallback } from "react";
+export declare namespace useThreadViewportAutoScroll {
+    type Options = {
+        /**
+         * 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;
+        /**
+         * 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;
+    };
+}
+export declare const useThreadViewportAutoScroll: <TElement extends HTMLElement>({ autoScroll, scrollToBottomOnRunStart, scrollToBottomOnInitialize, scrollToBottomOnThreadSwitch, }: useThreadViewportAutoScroll.Options) => RefCallback<TElement>;

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

@@ -0,0 +1,99 @@
+"use client";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { useCallback, useRef } from "react";
+import { useAuiEvent } from "@assistant-ui/store";
+import { useOnResizeContent } from "../../utils/hooks/useOnResizeContent";
+import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
+import { useManagedRef } from "../../utils/hooks/useManagedRef";
+import { writableStore } from "../../context/ReadonlyStore";
+import { useThreadViewportStore } from "../../context/react/ThreadViewportContext";
+export const useThreadViewportAutoScroll = ({ autoScroll, scrollToBottomOnRunStart = true, scrollToBottomOnInitialize = true, scrollToBottomOnThreadSwitch = true, }) => {
+    const divRef = useRef(null);
+    const threadViewportStore = useThreadViewportStore();
+    if (autoScroll === undefined) {
+        autoScroll = threadViewportStore.getState().turnAnchor !== "top";
+    }
+    const lastScrollTop = useRef(0);
+    // bug: when ScrollToBottom's button changes its disabled state, the scroll stops
+    // fix: delay the state change until the scroll is done
+    // stores the scroll behavior to reuse during content resize, or null if not scrolling
+    const scrollingToBottomBehaviorRef = useRef(null);
+    const scrollToBottom = useCallback((behavior) => {
+        const div = divRef.current;
+        if (!div)
+            return;
+        scrollingToBottomBehaviorRef.current = behavior;
+        div.scrollTo({ top: div.scrollHeight, behavior });
+    }, []);
+    const handleScroll = () => {
+        const div = divRef.current;
+        if (!div)
+            return;
+        const isAtBottom = threadViewportStore.getState().isAtBottom;
+        const newIsAtBottom = Math.abs(div.scrollHeight - div.scrollTop - div.clientHeight) < 1 ||
+            div.scrollHeight <= div.clientHeight;
+        if (!newIsAtBottom && lastScrollTop.current < div.scrollTop) {
+            // ignore scroll down
+        }
+        else {
+            if (newIsAtBottom) {
+                scrollingToBottomBehaviorRef.current = null;
+            }
+            const shouldUpdate = newIsAtBottom || scrollingToBottomBehaviorRef.current === null;
+            if (shouldUpdate && newIsAtBottom !== isAtBottom) {
+                writableStore(threadViewportStore).setState({
+                    isAtBottom: newIsAtBottom,
+                });
+            }
+        }
+        lastScrollTop.current = div.scrollTop;
+    };
+    const resizeRef = useOnResizeContent(() => {
+        const scrollBehavior = scrollingToBottomBehaviorRef.current;
+        if (scrollBehavior) {
+            scrollToBottom(scrollBehavior);
+        }
+        else if (autoScroll && threadViewportStore.getState().isAtBottom) {
+            scrollToBottom("instant");
+        }
+        handleScroll();
+    });
+    const scrollRef = useManagedRef((el) => {
+        el.addEventListener("scroll", handleScroll);
+        return () => {
+            el.removeEventListener("scroll", handleScroll);
+        };
+    });
+    useOnScrollToBottom(({ behavior }) => {
+        scrollToBottom(behavior);
+    });
+    // autoscroll on run start
+    useAuiEvent("thread.runStart", () => {
+        if (!scrollToBottomOnRunStart)
+            return;
+        scrollingToBottomBehaviorRef.current = "auto";
+        requestAnimationFrame(() => {
+            scrollToBottom("auto");
+        });
+    });
+    // scroll to bottom instantly when thread history is first loaded
+    useAuiEvent("thread.initialize", () => {
+        if (!scrollToBottomOnInitialize)
+            return;
+        scrollingToBottomBehaviorRef.current = "instant";
+        requestAnimationFrame(() => {
+            scrollToBottom("instant");
+        });
+    });
+    // scroll to bottom instantly when switching threads
+    useAuiEvent("threadListItem.switchedTo", () => {
+        if (!scrollToBottomOnThreadSwitch)
+            return;
+        scrollingToBottomBehaviorRef.current = "instant";
+        requestAnimationFrame(() => {
+            scrollToBottom("instant");
+        });
+    });
+    const autoScrollRef = useComposedRefs(resizeRef, scrollRef, divRef);
+    return autoScrollRef;
+};

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

@@ -0,0 +1,34 @@
+import { ComponentType, FC } from "react";
+export declare namespace ThreadListPrimitiveItems {
+    type Props = {
+        archived?: boolean | undefined;
+        components: {
+            ThreadListItem: ComponentType;
+        };
+    };
+}
+export declare namespace ThreadListPrimitiveItemByIndex {
+    type Props = {
+        index: number;
+        archived?: boolean | undefined;
+        components: ThreadListPrimitiveItems.Props["components"];
+    };
+}
+/**
+ * Renders a single thread list item at the specified index.
+ *
+ * This component provides direct access to render a specific thread
+ * from the thread list using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ThreadListPrimitive.ItemByIndex
+ *   index={0}
+ *   components={{
+ *     ThreadListItem: MyThreadListItem
+ *   }}
+ * />
+ * ```
+ */
+export declare const ThreadListPrimitiveItemByIndex: FC<ThreadListPrimitiveItemByIndex.Props>;
+export declare const ThreadListPrimitiveItems: FC<ThreadListPrimitiveItems.Props>;

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

@@ -0,0 +1,36 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from "react";
+import { useAuiState } from "@assistant-ui/store";
+import { ThreadListItemByIndexProvider } from "../../context/providers";
+/**
+ * Renders a single thread list item at the specified index.
+ *
+ * This component provides direct access to render a specific thread
+ * from the thread list using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ThreadListPrimitive.ItemByIndex
+ *   index={0}
+ *   components={{
+ *     ThreadListItem: MyThreadListItem
+ *   }}
+ * />
+ * ```
+ */
+export const ThreadListPrimitiveItemByIndex = memo(({ index, archived = false, components }) => {
+    const ThreadListItemComponent = components.ThreadListItem;
+    return (_jsx(ThreadListItemByIndexProvider, { index: index, archived: archived, children: _jsx(ThreadListItemComponent, {}) }));
+}, (prev, next) => prev.index === next.index &&
+    prev.archived === next.archived &&
+    prev.components.ThreadListItem === next.components.ThreadListItem);
+ThreadListPrimitiveItemByIndex.displayName = "ThreadListPrimitive.ItemByIndex";
+export const ThreadListPrimitiveItems = ({ archived = false, components, }) => {
+    const contentLength = useAuiState(({ threads }) => archived ? threads.archivedThreadIds.length : threads.threadIds.length);
+    const listElements = useMemo(() => {
+        return Array.from({ length: contentLength }, (_, index) => (_jsx(ThreadListPrimitiveItemByIndex, { index: index, archived: archived, components: components }, index)));
+    }, [contentLength, archived, components]);
+    return listElements;
+};
+ThreadListPrimitiveItems.displayName = "ThreadListPrimitive.Items";

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

@@ -0,0 +1,8 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+export declare namespace ThreadListPrimitiveNew {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<() => void>;
+}
+export declare const ThreadListPrimitiveNew: 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/threadList/ThreadListNew.js

@@ -0,0 +1,26 @@
+"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 { forwardRef } from "react";
+import { Primitive } from "@radix-ui/react-primitive";
+import { composeEventHandlers } from "@radix-ui/primitive";
+import { useAuiState, useAui } from "@assistant-ui/store";
+export const ThreadListPrimitiveNew = forwardRef((_a, forwardedRef) => {
+    var { onClick, disabled } = _a, props = __rest(_a, ["onClick", "disabled"]);
+    const isMain = useAuiState(({ threads }) => threads.newThreadId === threads.mainThreadId);
+    const aui = useAui();
+    return (_jsx(Primitive.button, Object.assign({ type: "button" }, (isMain ? { "data-active": "true", "aria-current": "true" } : null), props, { ref: forwardedRef, disabled: disabled, onClick: composeEventHandlers(onClick, () => {
+            aui.threads().switchToNewThread();
+        }) })));
+});
+ThreadListPrimitiveNew.displayName = "ThreadListPrimitive.New";

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

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

package/dist/vendor/assistant-ui-react/src/primitives/threadList/ThreadListRoot.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 ThreadListPrimitiveRoot = forwardRef((props, ref) => {
+    return _jsx(Primitive.div, Object.assign({}, props, { ref: ref }));
+});
+ThreadListPrimitiveRoot.displayName = "ThreadListPrimitive.Root";

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

@@ -0,0 +1,4 @@
+export { ThreadListPrimitiveNew as New } from "./ThreadListNew";
+export { ThreadListPrimitiveItems as Items } from "./ThreadListItems";
+export { ThreadListPrimitiveItemByIndex as ItemByIndex } from "./ThreadListItems";
+export { ThreadListPrimitiveRoot as Root } from "./ThreadListRoot";

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

@@ -0,0 +1,4 @@
+export { ThreadListPrimitiveNew as New } from "./ThreadListNew";
+export { ThreadListPrimitiveItems as Items } from "./ThreadListItems";
+export { ThreadListPrimitiveItemByIndex as ItemByIndex } from "./ThreadListItems";
+export { ThreadListPrimitiveRoot as Root } from "./ThreadListRoot";

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

@@ -0,0 +1,10 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useThreadListItemArchive: () => () => void;
+export declare namespace ThreadListItemPrimitiveArchive {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useThreadListItemArchive>;
+}
+export declare const ThreadListItemPrimitiveArchive: 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/threadListItem/ThreadListItemArchive.js

@@ -0,0 +1,11 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useAui } from "@assistant-ui/store";
+import { useCallback } from "react";
+const useThreadListItemArchive = () => {
+    const aui = useAui();
+    return useCallback(() => {
+        aui.threadListItem().archive();
+    }, [aui]);
+};
+export const ThreadListItemPrimitiveArchive = createActionButton("ThreadListItemPrimitive.Archive", useThreadListItemArchive);

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

@@ -0,0 +1,10 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useThreadListItemDelete: () => () => void;
+export declare namespace ThreadListItemPrimitiveDelete {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useThreadListItemDelete>;
+}
+export declare const ThreadListItemPrimitiveDelete: 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/threadListItem/ThreadListItemDelete.js

@@ -0,0 +1,11 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useAui } from "@assistant-ui/store";
+import { useCallback } from "react";
+const useThreadListItemDelete = () => {
+    const aui = useAui();
+    return useCallback(() => {
+        aui.threadListItem().delete();
+    }, [aui]);
+};
+export const ThreadListItemPrimitiveDelete = createActionButton("ThreadListItemPrimitive.Delete", useThreadListItemDelete);

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

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

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

@@ -0,0 +1,10 @@
+"use client";
+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 ThreadListItemPrimitiveRoot = forwardRef((props, ref) => {
+    const isMain = useAuiState(({ threads, threadListItem }) => threads.mainThreadId === threadListItem.id);
+    return (_jsx(Primitive.div, Object.assign({}, (isMain ? { "data-active": "true", "aria-current": "true" } : null), props, { ref: ref })));
+});
+ThreadListItemPrimitiveRoot.displayName = "ThreadListItemPrimitive.Root";

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

@@ -0,0 +1,7 @@
+import type { FC, ReactNode } from "react";
+export declare namespace ThreadListItemPrimitiveTitle {
+    type Props = {
+        fallback?: ReactNode;
+    };
+}
+export declare const ThreadListItemPrimitiveTitle: FC<ThreadListItemPrimitiveTitle.Props>;

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

@@ -0,0 +1,8 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useAuiState } from "@assistant-ui/store";
+export const ThreadListItemPrimitiveTitle = ({ fallback }) => {
+    const title = useAuiState(({ threadListItem }) => threadListItem.title);
+    return _jsx(_Fragment, { children: title || fallback });
+};
+ThreadListItemPrimitiveTitle.displayName = "ThreadListItemPrimitive.Title";

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

@@ -0,0 +1,10 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useThreadListItemTrigger: () => () => void;
+export declare namespace ThreadListItemPrimitiveTrigger {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useThreadListItemTrigger>;
+}
+export declare const ThreadListItemPrimitiveTrigger: 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/threadListItem/ThreadListItemTrigger.js

@@ -0,0 +1,11 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useAui } from "@assistant-ui/store";
+import { useCallback } from "react";
+const useThreadListItemTrigger = () => {
+    const aui = useAui();
+    return useCallback(() => {
+        aui.threadListItem().switchTo();
+    }, [aui]);
+};
+export const ThreadListItemPrimitiveTrigger = createActionButton("ThreadListItemPrimitive.Trigger", useThreadListItemTrigger);

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

@@ -0,0 +1,10 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useThreadListItemUnarchive: () => () => void;
+export declare namespace ThreadListItemPrimitiveUnarchive {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useThreadListItemUnarchive>;
+}
+export declare const ThreadListItemPrimitiveUnarchive: 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/threadListItem/ThreadListItemUnarchive.js

@@ -0,0 +1,11 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useAui } from "@assistant-ui/store";
+import { useCallback } from "react";
+const useThreadListItemUnarchive = () => {
+    const aui = useAui();
+    return useCallback(() => {
+        aui.threadListItem().unarchive();
+    }, [aui]);
+};
+export const ThreadListItemPrimitiveUnarchive = createActionButton("ThreadListItemPrimitive.Unarchive", useThreadListItemUnarchive);

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

@@ -0,0 +1,6 @@
+export { ThreadListItemPrimitiveRoot as Root } from "./ThreadListItemRoot";
+export { ThreadListItemPrimitiveArchive as Archive } from "./ThreadListItemArchive";
+export { ThreadListItemPrimitiveUnarchive as Unarchive } from "./ThreadListItemUnarchive";
+export { ThreadListItemPrimitiveDelete as Delete } from "./ThreadListItemDelete";
+export { ThreadListItemPrimitiveTrigger as Trigger } from "./ThreadListItemTrigger";
+export { ThreadListItemPrimitiveTitle as Title } from "./ThreadListItemTitle";

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

@@ -0,0 +1,6 @@
+export { ThreadListItemPrimitiveRoot as Root } from "./ThreadListItemRoot";
+export { ThreadListItemPrimitiveArchive as Archive } from "./ThreadListItemArchive";
+export { ThreadListItemPrimitiveUnarchive as Unarchive } from "./ThreadListItemUnarchive";
+export { ThreadListItemPrimitiveDelete as Delete } from "./ThreadListItemDelete";
+export { ThreadListItemPrimitiveTrigger as Trigger } from "./ThreadListItemTrigger";
+export { ThreadListItemPrimitiveTitle as Title } from "./ThreadListItemTitle";

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

@@ -0,0 +1,11 @@
+import { ComponentPropsWithoutRef, ComponentRef } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+export declare namespace ThreadListItemMorePrimitiveContent {
+    type Element = ComponentRef<typeof DropdownMenuPrimitive.Content>;
+    type Props = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> & {
+        portalProps?: ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Portal> | undefined;
+    };
+}
+export declare const ThreadListItemMorePrimitiveContent: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+    portalProps?: ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Portal> | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,23 @@
+"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 { forwardRef } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { useDropdownMenuScope } from "./scope";
+export const ThreadListItemMorePrimitiveContent = forwardRef((_a, forwardedRef) => {
+    var { __scopeThreadListItemMore, portalProps, sideOffset = 4 } = _a, props = __rest(_a, ["__scopeThreadListItemMore", "portalProps", "sideOffset"]);
+    const scope = useDropdownMenuScope(__scopeThreadListItemMore);
+    return (_jsx(DropdownMenuPrimitive.Portal, Object.assign({}, scope, portalProps, { children: _jsx(DropdownMenuPrimitive.Content, Object.assign({}, scope, props, { ref: forwardedRef, sideOffset: sideOffset })) })));
+});
+ThreadListItemMorePrimitiveContent.displayName =
+    "ThreadListItemMorePrimitive.Content";

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

@@ -0,0 +1,7 @@
+import { ComponentPropsWithoutRef, ComponentRef } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+export declare namespace ThreadListItemMorePrimitiveItem {
+    type Element = ComponentRef<typeof DropdownMenuPrimitive.Item>;
+    type Props = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item>;
+}
+export declare const ThreadListItemMorePrimitiveItem: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,23 @@
+"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 { forwardRef } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { useDropdownMenuScope } from "./scope";
+export const ThreadListItemMorePrimitiveItem = forwardRef((_a, ref) => {
+    var { __scopeThreadListItemMore } = _a, rest = __rest(_a, ["__scopeThreadListItemMore"]);
+    const scope = useDropdownMenuScope(__scopeThreadListItemMore);
+    return _jsx(DropdownMenuPrimitive.Item, Object.assign({}, scope, rest, { ref: ref }));
+});
+ThreadListItemMorePrimitiveItem.displayName =
+    "ThreadListItemMorePrimitive.Item";

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

@@ -0,0 +1,6 @@
+import { FC } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+export declare namespace ThreadListItemMorePrimitiveRoot {
+    type Props = DropdownMenuPrimitive.DropdownMenuProps;
+}
+export declare const ThreadListItemMorePrimitiveRoot: FC<ThreadListItemMorePrimitiveRoot.Props>;