@vllnt/ui 0.2.0 → 0.2.1-canary.06f0e84

package/dist/components/conversation-thread/conversation-thread.js

@@ -0,0 +1,348 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import {
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { ArrowDown, RefreshCw, ThumbsDown, ThumbsUp } from "lucide-react";
+import { cn } from "../../lib/utils";
+import { ThinkingBlock } from "../thinking-block";
+const ConversationThreadContext = createContext(null);
+function useConversationThreadContext() {
+  const ctx = useContext(ConversationThreadContext);
+  if (!ctx) {
+    throw new Error(
+      "ConversationThread compound components must be used within <ConversationThread>"
+    );
+  }
+  return ctx;
+}
+function MessageActions({ messageId }) {
+  const { onFeedback, onRetry } = useConversationThreadContext();
+  return /* @__PURE__ */ jsxs("div", { className: "mt-2 flex items-center gap-1", children: [
+    onRetry ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        "aria-label": "Retry message",
+        className: "rounded p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground",
+        onClick: () => {
+          onRetry(messageId);
+        },
+        type: "button",
+        children: /* @__PURE__ */ jsx(RefreshCw, { className: "h-3 w-3" })
+      }
+    ) : null,
+    onFeedback ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          "aria-label": "Positive feedback",
+          className: "rounded p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground",
+          onClick: () => {
+            onFeedback(messageId, "positive");
+          },
+          type: "button",
+          children: /* @__PURE__ */ jsx(ThumbsUp, { className: "h-3 w-3" })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          "aria-label": "Negative feedback",
+          className: "rounded p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground",
+          onClick: () => {
+            onFeedback(messageId, "negative");
+          },
+          type: "button",
+          children: /* @__PURE__ */ jsx(ThumbsDown, { className: "h-3 w-3" })
+        }
+      )
+    ] }) : null
+  ] });
+}
+function MessageItem({ message }) {
+  const isUser = message.role === "user";
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "mb-4 flex gap-3",
+        isUser ? "justify-end" : "justify-start"
+      ),
+      children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: cn(
+            "max-w-[80%] rounded-2xl px-4 py-3 text-sm",
+            isUser ? "rounded-br-sm bg-primary text-primary-foreground" : "rounded-bl-sm bg-muted text-foreground"
+          ),
+          children: [
+            !isUser && message.thinking ? /* @__PURE__ */ jsx(
+              ThinkingBlock,
+              {
+                isStreaming: message.isStreaming,
+                thinking: message.thinking
+              }
+            ) : null,
+            message.toolCalls && message.toolCalls.length > 0 ? /* @__PURE__ */ jsx(
+              "ul",
+              {
+                "aria-label": "Tool calls",
+                className: "mb-2 flex flex-col gap-1 text-xs text-muted-foreground",
+                children: message.toolCalls.map((toolCall) => /* @__PURE__ */ jsx("li", { className: "font-mono", children: toolCall.name }, toolCall.id))
+              }
+            ) : null,
+            /* @__PURE__ */ jsx("p", { className: "whitespace-pre-wrap leading-relaxed", children: message.content }),
+            isUser ? null : /* @__PURE__ */ jsx(MessageActions, { messageId: message.id })
+          ]
+        }
+      )
+    }
+  );
+}
+function useConversationScroll(messages, isStreaming) {
+  const scrollContainerRef = useRef(null);
+  const messagesEndRef = useRef(null);
+  const isAtBottomRef = useRef(true);
+  const [isAtBottom, setIsAtBottom] = useState(true);
+  const scrollToBottom = useCallback(() => {
+    const element = messagesEndRef.current;
+    if (element && typeof element.scrollIntoView === "function") {
+      element.scrollIntoView({ behavior: "smooth" });
+    }
+  }, []);
+  const scrollToBottomInstant = useCallback(() => {
+    const element = messagesEndRef.current;
+    if (element && typeof element.scrollIntoView === "function") {
+      element.scrollIntoView({ behavior: "instant" });
+    }
+  }, []);
+  const handleScroll = useCallback(() => {
+    const container = scrollContainerRef.current;
+    if (!container) return;
+    const { clientHeight, scrollHeight, scrollTop } = container;
+    const nearBottom = scrollHeight - scrollTop - clientHeight <= 100;
+    isAtBottomRef.current = nearBottom;
+    setIsAtBottom(nearBottom);
+  }, []);
+  useEffect(() => {
+    if (!isAtBottomRef.current) return;
+    scrollToBottomInstant();
+  }, [messages, scrollToBottomInstant]);
+  useEffect(() => {
+    if (!isStreaming || !isAtBottomRef.current) return;
+    scrollToBottomInstant();
+  }, [isStreaming, scrollToBottomInstant]);
+  return {
+    handleScroll,
+    isAtBottom,
+    messagesEndRef,
+    scrollContainerRef,
+    scrollToBottom
+  };
+}
+const ConversationThread = forwardRef(
+  ({
+    children,
+    className,
+    isStreaming = false,
+    messages,
+    onFeedback,
+    onRetry,
+    onSend
+  }, reference) => {
+    const {
+      handleScroll,
+      isAtBottom,
+      messagesEndRef,
+      scrollContainerRef,
+      scrollToBottom
+    } = useConversationScroll(messages, isStreaming);
+    const contextValue = useMemo(
+      () => ({
+        handleScroll,
+        isAtBottom,
+        isStreaming,
+        messages,
+        messagesEndRef,
+        onFeedback,
+        onRetry,
+        onSend,
+        scrollContainerRef,
+        scrollToBottom
+      }),
+      [
+        handleScroll,
+        isAtBottom,
+        isStreaming,
+        messages,
+        messagesEndRef,
+        onFeedback,
+        onRetry,
+        onSend,
+        scrollContainerRef,
+        scrollToBottom
+      ]
+    );
+    return /* @__PURE__ */ jsx(ConversationThreadContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: cn("flex h-full flex-col overflow-hidden", className),
+        ref: reference,
+        children
+      }
+    ) });
+  }
+);
+ConversationThread.displayName = "ConversationThread";
+const ConversationHeader = forwardRef(({ children, className }, reference) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn("flex shrink-0 items-center border-b px-4 py-3", className),
+      ref: reference,
+      children
+    }
+  );
+});
+ConversationHeader.displayName = "ConversationHeader";
+const ConversationTitle = forwardRef(({ children, className }, reference) => {
+  return /* @__PURE__ */ jsx(
+    "h2",
+    {
+      className: cn("text-sm font-semibold leading-none", className),
+      ref: reference,
+      children
+    }
+  );
+});
+ConversationTitle.displayName = "ConversationTitle";
+const ConversationMessages = forwardRef(({ children, className }, reference) => {
+  const { handleScroll, messages, messagesEndRef, scrollContainerRef } = useConversationThreadContext();
+  return /* @__PURE__ */ jsxs("div", { className: cn("relative min-h-0 flex-1", className), ref: reference, children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-label": "Conversation messages",
+        "aria-live": "polite",
+        className: "absolute inset-0 overflow-y-auto",
+        onScroll: handleScroll,
+        ref: scrollContainerRef,
+        role: "log",
+        children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col p-4", children: [
+          messages.map((message) => /* @__PURE__ */ jsx(MessageItem, { message }, message.id)),
+          /* @__PURE__ */ jsx("div", { "aria-hidden": "true", ref: messagesEndRef })
+        ] })
+      }
+    ),
+    children
+  ] });
+});
+ConversationMessages.displayName = "ConversationMessages";
+const ConversationEmpty = forwardRef(({ children, className }, reference) => {
+  const { messages } = useConversationThreadContext();
+  if (messages.length > 0) return null;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "pointer-events-none absolute inset-0 flex flex-col items-center justify-center gap-4 p-8",
+        className
+      ),
+      ref: reference,
+      children: /* @__PURE__ */ jsx("div", { className: "pointer-events-auto flex flex-col items-center gap-4", children })
+    }
+  );
+});
+ConversationEmpty.displayName = "ConversationEmpty";
+const ConversationSuggestions = forwardRef(({ className, suggestions = [] }, reference) => {
+  const { onSend } = useConversationThreadContext();
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn("flex flex-wrap justify-center gap-2", className),
+      ref: reference,
+      children: suggestions.map((suggestion) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          className: "rounded-full border bg-background px-4 py-2 text-sm transition-colors hover:bg-muted",
+          onClick: () => onSend?.(suggestion),
+          type: "button",
+          children: suggestion
+        },
+        suggestion
+      ))
+    }
+  );
+});
+ConversationSuggestions.displayName = "ConversationSuggestions";
+const ConversationScrollButton = forwardRef(({ className }, reference) => {
+  const { isAtBottom, scrollToBottom } = useConversationThreadContext();
+  if (isAtBottom) return null;
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      "aria-label": "Scroll to bottom",
+      className: cn(
+        "absolute bottom-4 right-4 flex h-8 w-8 items-center justify-center rounded-full border bg-background shadow-md transition-colors hover:bg-muted",
+        className
+      ),
+      onClick: scrollToBottom,
+      ref: reference,
+      type: "button",
+      children: /* @__PURE__ */ jsx(ArrowDown, { className: "h-4 w-4" })
+    }
+  );
+});
+ConversationScrollButton.displayName = "ConversationScrollButton";
+const ConversationLoading = forwardRef(({ className }, reference) => {
+  const { isStreaming, messages } = useConversationThreadContext();
+  const lastMessage = messages.at(-1);
+  if (!isStreaming || lastMessage?.role !== "assistant") return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "aria-label": "Assistant is typing",
+      className: cn(
+        "absolute bottom-4 left-4 flex items-center gap-1",
+        className
+      ),
+      ref: reference,
+      role: "status",
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "h-2 w-2 animate-bounce rounded-full bg-muted-foreground",
+            style: { animationDelay: "-0.3s" }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "h-2 w-2 animate-bounce rounded-full bg-muted-foreground",
+            style: { animationDelay: "-0.15s" }
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "h-2 w-2 animate-bounce rounded-full bg-muted-foreground" })
+      ]
+    }
+  );
+});
+ConversationLoading.displayName = "ConversationLoading";
+export {
+  ConversationEmpty,
+  ConversationHeader,
+  ConversationLoading,
+  ConversationMessages,
+  ConversationScrollButton,
+  ConversationSuggestions,
+  ConversationThread,
+  ConversationTitle
+};

package/dist/components/conversation-thread/index.js

@@ -0,0 +1,20 @@
+import {
+  ConversationEmpty,
+  ConversationHeader,
+  ConversationLoading,
+  ConversationMessages,
+  ConversationScrollButton,
+  ConversationSuggestions,
+  ConversationThread,
+  ConversationTitle
+} from "./conversation-thread";
+export {
+  ConversationEmpty,
+  ConversationHeader,
+  ConversationLoading,
+  ConversationMessages,
+  ConversationScrollButton,
+  ConversationSuggestions,
+  ConversationThread,
+  ConversationTitle
+};

package/dist/components/copy-button/copy-button.js

@@ -0,0 +1,189 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { Check, Copy } from "lucide-react";
+import { cn } from "../../lib/utils";
+import { Button } from "../button/button";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger
+} from "../tooltip/tooltip";
+const FALLBACK_TIMEOUT_MS = 2e3;
+function useCopyToClipboard(options = {}) {
+  const { timeout = FALLBACK_TIMEOUT_MS } = options;
+  const [copied, setCopied] = useState(false);
+  const timerRef = useRef(void 0);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current !== void 0) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  const reset = useCallback(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    setCopied(false);
+  }, []);
+  const copy = useCallback(
+    async (value) => {
+      try {
+        if (typeof navigator === "undefined" || typeof navigator.clipboard?.writeText !== "function") {
+          return false;
+        }
+        await navigator.clipboard.writeText(value);
+        if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+        setCopied(true);
+        timerRef.current = setTimeout(() => {
+          setCopied(false);
+        }, timeout);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    [timeout]
+  );
+  return { copied, copy, reset };
+}
+function CopyIcon({
+  className,
+  copied,
+  size
+}) {
+  const Icon = copied ? Check : Copy;
+  const sizeClass = size === "xs" ? "h-3 w-3" : "h-4 w-4";
+  return /* @__PURE__ */ jsx(Icon, { "aria-hidden": "true", className: cn(sizeClass, className) });
+}
+const ButtonTrigger = forwardRef(
+  ({
+    accessibleLabel,
+    className,
+    copied,
+    copiedText,
+    iconClassName,
+    label = "Copy",
+    onClick: _onClick,
+    onClickHandler,
+    value: _value,
+    variant = "icon",
+    ...rest
+  }, ref) => {
+    if (variant === "button") {
+      return /* @__PURE__ */ jsxs(
+        Button,
+        {
+          "aria-label": accessibleLabel,
+          className: cn(className),
+          onClick: onClickHandler,
+          ref,
+          size: "sm",
+          type: "button",
+          variant: "outline",
+          ...rest,
+          children: [
+            /* @__PURE__ */ jsx(CopyIcon, { className: iconClassName, copied, size: "sm" }),
+            /* @__PURE__ */ jsx("span", { children: copied ? copiedText : label })
+          ]
+        }
+      );
+    }
+    if (variant === "inline") {
+      return /* @__PURE__ */ jsx(
+        Button,
+        {
+          "aria-label": accessibleLabel,
+          className: cn(
+            "h-6 w-6 align-middle text-muted-foreground hover:text-foreground",
+            className
+          ),
+          onClick: onClickHandler,
+          ref,
+          size: "icon",
+          type: "button",
+          variant: "ghost",
+          ...rest,
+          children: /* @__PURE__ */ jsx(CopyIcon, { className: iconClassName, copied, size: "xs" })
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      Button,
+      {
+        "aria-label": accessibleLabel,
+        className: cn("h-8 w-8", className),
+        onClick: onClickHandler,
+        ref,
+        size: "icon",
+        type: "button",
+        variant: "ghost",
+        ...rest,
+        children: /* @__PURE__ */ jsx(CopyIcon, { className: iconClassName, copied, size: "sm" })
+      }
+    );
+  }
+);
+ButtonTrigger.displayName = "CopyButton.Trigger";
+const CopyButton = forwardRef(
+  ({
+    "aria-label": ariaLabelOverride,
+    copiedLabel = "Copied!",
+    label = "Copy",
+    onClick,
+    showTooltip = true,
+    timeout = FALLBACK_TIMEOUT_MS,
+    value,
+    ...rest
+  }, ref) => {
+    const { copied, copy } = useCopyToClipboard({ timeout });
+    const handleClick = useCallback(
+      (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented) return;
+        void copy(value);
+      },
+      [copy, onClick, value]
+    );
+    const accessibleLabel = ariaLabelOverride ?? (copied ? copiedLabel : label);
+    const tooltipText = copied ? copiedLabel : label;
+    const trigger = /* @__PURE__ */ jsx(
+      ButtonTrigger,
+      {
+        ...rest,
+        accessibleLabel,
+        copied,
+        copiedText: copiedLabel,
+        label,
+        onClickHandler: handleClick,
+        ref,
+        value
+      }
+    );
+    const liveRegion = /* @__PURE__ */ jsx("span", { "aria-live": "polite", className: "sr-only", role: "status", children: copied ? copiedLabel : "" });
+    if (!showTooltip) {
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        trigger,
+        liveRegion
+      ] });
+    }
+    return /* @__PURE__ */ jsxs(TooltipProvider, { delayDuration: 200, children: [
+      /* @__PURE__ */ jsxs(Tooltip, { children: [
+        /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: trigger }),
+        /* @__PURE__ */ jsx(TooltipContent, { children: tooltipText })
+      ] }),
+      liveRegion
+    ] });
+  }
+);
+CopyButton.displayName = "CopyButton";
+export {
+  CopyButton,
+  useCopyToClipboard
+};

package/dist/components/copy-button/index.js

@@ -0,0 +1,8 @@
+import {
+  CopyButton,
+  useCopyToClipboard
+} from "./copy-button";
+export {
+  CopyButton,
+  useCopyToClipboard
+};