@duskmoon-dev/components 0.3.1 → 0.3.3

package/dist/components/anchor/index.js

@@ -235,6 +235,6 @@ var Anchor = forwardRef(({
 Anchor.displayName = "Anchor";
 Anchor.Link = AnchorLink;
 export {
-  AnchorLink,
-  Anchor
+  Anchor,
+  AnchorLink
 };

package/dist/components/app/index.js

@@ -1,7 +1,13 @@
 "use client";
 
-// src/components/message/Message.tsx
-import React, { useSyncExternalStore } from "react";
+// src/components/app/App.tsx
+import {
+  createContext,
+  forwardRef as forwardRef2,
+  useContext,
+  useEffect as useEffect3,
+  useMemo as useMemo2
+} from "react";
 
 // ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
 function r(e) {
@@ -28,6 +34,20 @@ function clsx() {
 function cn(...inputs) {
   return clsx(inputs);
 }
+// src/classes/app.ts
+var appClass = "app";
+var appRootClass = "app-root";
+var appHolderClass = "app-holder";
+function getAppClasses({ className }) {
+  return cn(appClass, className);
+}
+function getAppRootClasses({ className }) {
+  return cn(appRootClass, className);
+}
+
+// src/components/message/Message.tsx
+import React, { useSyncExternalStore } from "react";
+
 // src/classes/message.ts
 var messageHolderClass = "message-holder";
 var messageBaseClass = "message";
@@ -154,13 +174,13 @@ function config(nextConfig) {
   emit();
 }
 function MessageHolder({ className }) {
-  const snapshot2 = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   return /* @__PURE__ */ jsx("div", {
     className: getMessageHolderClasses({
-      placement: snapshot2.config.placement,
+      placement: snapshot.config.placement,
       className
     }),
-    children: snapshot2.messages.map((item) => /* @__PURE__ */ jsxs("div", {
+    children: snapshot.messages.map((item) => /* @__PURE__ */ jsxs("div", {
       className: getMessageClasses({
         type: item.type,
         className: item.className
@@ -219,11 +239,11 @@ var modalCloseClass = "modal-close";
 var modalBodyClass = "modal-body";
 var modalFooterClass = "modal-footer";
 function getModalBackdropClasses({
-  open: open2,
+  open,
   centered,
   className
 }) {
-  return cn(modalBackdropClass, open2 && modalOpenClass, centered && modalBackdropCenterClass, className);
+  return cn(modalBackdropClass, open && modalOpenClass, centered && modalBackdropCenterClass, className);
 }
 function getModalClasses({ className }) {
   return cn(modalClass, className);
@@ -233,8 +253,8 @@ function getModalClasses({ className }) {
 import { jsx as jsx2, jsxs as jsxs2, Fragment } from "react/jsx-runtime";
 var defaultCloseIcon = "x";
 var serviceHandles = new Set;
-function createServiceHandle(config2) {
-  let currentConfig = config2;
+function createServiceHandle(config) {
+  let currentConfig = config;
   const handle = {
     destroy: () => {
       serviceHandles.delete(handle);
@@ -256,7 +276,7 @@ function getModalStyle({
   };
 }
 var ModalBase = forwardRef(({
-  open: open2,
+  open,
   defaultOpen = false,
   title,
   children,
@@ -280,9 +300,9 @@ var ModalBase = forwardRef(({
   role = "dialog",
   ...props
 }, ref) => {
-  const controlled = open2 !== undefined;
+  const controlled = open !== undefined;
   const [innerOpen, setInnerOpen] = useState(defaultOpen);
-  const mergedOpen = controlled ? Boolean(open2) : innerOpen;
+  const mergedOpen = controlled ? Boolean(open) : innerOpen;
   const previousOpen = useRef(mergedOpen);
   const showClose = closable && closeIcon !== null && closeIcon !== false;
   const body = children ?? content;
@@ -425,10 +445,10 @@ function getNotificationHolderClasses({
 }
 function getNotificationNoticeClasses({
   type = "info",
-  open: open2 = true,
+  open = true,
   className
 }) {
-  return cn("toast", "alert", notificationNoticeClass, notificationTypeClasses[type], open2 && "toast-show", open2 && notificationNoticeOpenClass, className);
+  return cn("toast", "alert", notificationNoticeClass, notificationTypeClasses[type], open && "toast-show", open && notificationNoticeOpenClass, className);
 }
 
 // src/components/notification/Notification.tsx
@@ -457,11 +477,11 @@ function getKey(key) {
   globalCounter += 1;
   return `notification-${globalCounter}`;
 }
-function getDuration(config2, holderConfig) {
-  return config2.duration ?? holderConfig.duration ?? defaultConfig.duration;
+function getDuration(config, holderConfig) {
+  return config.duration ?? holderConfig.duration ?? defaultConfig.duration;
 }
-function getPlacement(config2, holderConfig) {
-  return config2.placement ?? holderConfig.placement ?? defaultConfig.placement;
+function getPlacement(config, holderConfig) {
+  return config.placement ?? holderConfig.placement ?? defaultConfig.placement;
 }
 function applyMaxCount(notices, maxCount) {
   if (!maxCount || notices.length <= maxCount) {
@@ -539,42 +559,42 @@ function destroyGlobal(key) {
   globalNotices = [];
   emitGlobal();
 }
-function openGlobal(config2) {
-  const key = getKey(config2.key);
+function openGlobal(config) {
+  const key = getKey(config.key);
   const notice = {
-    ...config2,
+    ...config,
     key,
-    placement: getPlacement(config2, globalConfig2),
-    type: config2.type ?? "info"
+    placement: getPlacement(config, globalConfig2),
+    type: config.type ?? "info"
   };
   clearTimer2(key);
   globalNotices = applyMaxCount([...globalNotices.filter((item) => item.key !== key), notice], globalConfig2.maxCount);
-  const duration = getDuration(config2, globalConfig2);
+  const duration = getDuration(config, globalConfig2);
   if (duration && duration > 0) {
     globalTimers.set(key, setTimeout(() => closeGlobal(key), duration * 1000));
   }
   emitGlobal();
 }
-function withType(type, config2) {
-  openGlobal({ ...config2, type });
+function withType(type, config) {
+  openGlobal({ ...config, type });
 }
 var globalApi = {
   open: openGlobal,
-  success: (config2) => withType("success", config2),
-  info: (config2) => withType("info", config2),
-  warning: (config2) => withType("warning", config2),
-  error: (config2) => withType("error", config2),
+  success: (config) => withType("success", config),
+  info: (config) => withType("info", config),
+  warning: (config) => withType("warning", config),
+  error: (config) => withType("error", config),
   close: closeGlobal,
   destroy: destroyGlobal,
-  config: (config2) => {
-    globalConfig2 = { ...globalConfig2, ...config2 };
+  config: (config) => {
+    globalConfig2 = { ...globalConfig2, ...config };
     emitGlobal();
   },
   useNotification
 };
 function NotificationHolder({
   notices,
-  config: config2,
+  config,
   onClose
 }) {
   const groups = groupByPlacement(notices);
@@ -583,7 +603,7 @@ function NotificationHolder({
       if (group.length === 0) {
         return null;
       }
-      const offsetStyle = placement.startsWith("bottom") && config2.bottom !== undefined ? { bottom: config2.bottom } : config2.top !== undefined ? { top: config2.top } : undefined;
+      const offsetStyle = placement.startsWith("bottom") && config.bottom !== undefined ? { bottom: config.bottom } : config.top !== undefined ? { top: config.top } : undefined;
       return /* @__PURE__ */ jsx3("div", {
         className: getNotificationHolderClasses({
           placement
@@ -591,7 +611,7 @@ function NotificationHolder({
         style: offsetStyle,
         children: group.map((notice) => /* @__PURE__ */ jsx3(NotificationNotice, {
           notice,
-          fallbackCloseIcon: config2.closeIcon,
+          fallbackCloseIcon: config.closeIcon,
           onClose
         }, notice.key))
       }, placement);
@@ -678,30 +698,30 @@ function createScopedApi({
       return current.filter((item) => item.key !== key);
     });
   }
-  function open2(config2) {
-    const key = getKey(config2.key);
+  function open(config) {
+    const key = getKey(config.key);
     const notice = {
-      ...config2,
+      ...config,
       key,
-      placement: getPlacement(config2, holderConfig),
-      type: config2.type ?? "info"
+      placement: getPlacement(config, holderConfig),
+      type: config.type ?? "info"
     };
     clearScopedTimer(key);
     setNotices((current) => applyMaxCount([...current.filter((item) => item.key !== key), notice], holderConfig.maxCount));
-    const duration = getDuration(config2, holderConfig);
+    const duration = getDuration(config, holderConfig);
     if (duration && duration > 0) {
       timerMap.set(key, setTimeout(() => close(key), duration * 1000));
     }
   }
-  function typed(type, config2) {
-    open2({ ...config2, type });
+  function typed(type, config) {
+    open({ ...config, type });
   }
   return {
-    open: open2,
-    success: (config2) => typed("success", config2),
-    info: (config2) => typed("info", config2),
-    warning: (config2) => typed("warning", config2),
-    error: (config2) => typed("error", config2),
+    open,
+    success: (config) => typed("success", config),
+    info: (config) => typed("info", config),
+    warning: (config) => typed("warning", config),
+    error: (config) => typed("error", config),
     close,
     destroy: (key) => {
       if (key !== undefined) {
@@ -720,24 +740,24 @@ function createScopedApi({
     }
   };
 }
-function useNotification(config2 = {}) {
+function useNotification(config = {}) {
   const holderConfig = useMemo(() => ({
     ...defaultConfig,
-    bottom: config2.bottom,
-    closeIcon: config2.closeIcon,
-    duration: config2.duration ?? defaultConfig.duration,
-    getContainer: config2.getContainer,
-    maxCount: config2.maxCount,
-    placement: config2.placement ?? defaultConfig.placement,
-    top: config2.top
+    bottom: config.bottom,
+    closeIcon: config.closeIcon,
+    duration: config.duration ?? defaultConfig.duration,
+    getContainer: config.getContainer,
+    maxCount: config.maxCount,
+    placement: config.placement ?? defaultConfig.placement,
+    top: config.top
   }), [
-    config2.bottom,
-    config2.closeIcon,
-    config2.duration,
-    config2.getContainer,
-    config2.maxCount,
-    config2.placement,
-    config2.top
+    config.bottom,
+    config.closeIcon,
+    config.duration,
+    config.getContainer,
+    config.maxCount,
+    config.placement,
+    config.top
   ]);
   const [notices, setNotices] = useState2([]);
   const [timerMap] = useState2(() => new Map);
@@ -772,26 +792,6 @@ function useNotification(config2 = {}) {
   ];
 }
 var notification = globalApi;
-// src/components/app/App.tsx
-import {
-  createContext,
-  forwardRef as forwardRef2,
-  useContext,
-  useEffect as useEffect3,
-  useMemo as useMemo2
-} from "react";
-
-// src/classes/app.ts
-var appClass = "app";
-var appRootClass = "app-root";
-var appHolderClass = "app-holder";
-function getAppClasses({ className }) {
-  return cn(appClass, className);
-}
-function getAppRootClasses({ className }) {
-  return cn(appRootClass, className);
-}
-
 // src/components/app/App.tsx
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var fallbackContext = {
@@ -877,7 +877,7 @@ function AppRoot({ className, ...props }) {
   });
 }
 export {
-  AppRoot,
+  App,
   AppContext,
-  App
+  AppRoot
 };

package/dist/components/cascader/index.js

@@ -402,9 +402,9 @@ var CascaderRoot = forwardRef(({
       });
     }
     if (multiple) {
-      return selectedPaths.map((path2, index) => /* @__PURE__ */ jsx("span", {
+      return selectedPaths.map((path, index) => /* @__PURE__ */ jsx("span", {
         className: cascaderTagClass,
-        children: displayRender ? displayRender(labelsForPath(path2, names), path2) : defaultDisplay(labelsForPath(path2, names))
+        children: displayRender ? displayRender(labelsForPath(path, names), path) : defaultDisplay(labelsForPath(path, names))
       }, valueKey(selectedValues[index] ?? [])));
     }
     const path = selectedPaths[0] ?? [];

package/dist/components/chat/Chat.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { ChatBubbleProps, ChatComponent, ChatToolProps, ChatTypingProps } from "./Chat.types";
+export declare const ChatAvatar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ChatHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ChatBubble: React.ForwardRefExoticComponent<Omit<ChatBubbleProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ChatFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ChatReasoning: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>, "ref"> & React.RefAttributes<HTMLDetailsElement>>;
+export declare const ChatTool: React.ForwardRefExoticComponent<Omit<ChatToolProps, "ref"> & React.RefAttributes<HTMLDetailsElement>>;
+export declare const ChatToolHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export declare const ChatToolStatus: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export declare const ChatToolCall: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ChatToolResult: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const ChatTyping: React.ForwardRefExoticComponent<Omit<ChatTypingProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export declare const Chat: ChatComponent;

package/dist/components/chat/Chat.types.d.ts

@@ -0,0 +1,47 @@
+import type { ComponentProps, ForwardRefExoticComponent, RefAttributes } from "react";
+export type ChatPlacement = "start" | "end";
+export type ChatBubbleColor = "primary" | "secondary" | "tertiary" | "accent" | "neutral" | "base" | "info" | "success" | "warning" | "error";
+export type ChatBubbleSize = "xs" | "sm" | "md" | "lg";
+export type ChatToolState = "pending" | "running" | "success" | "error";
+export interface ChatProps extends ComponentProps<"div"> {
+    /** Position the turn at the start or end of the conversation row. */
+    placement?: ChatPlacement;
+}
+export type ChatAvatarProps = ComponentProps<"div">;
+export type ChatHeaderProps = ComponentProps<"div">;
+export type ChatFooterProps = ComponentProps<"div">;
+export interface ChatBubbleProps extends ComponentProps<"div"> {
+    /** Apply a semantic DuskMoon color to the bubble. */
+    color?: ChatBubbleColor;
+    /** Control the bubble padding and font size. @default "md" */
+    size?: ChatBubbleSize;
+    /** Use the saturated form of the selected color. */
+    filled?: boolean;
+    /** Show the live streaming caret after the bubble content. */
+    streaming?: boolean;
+}
+export type ChatReasoningProps = ComponentProps<"details">;
+export interface ChatToolProps extends ComponentProps<"details"> {
+    /** Reflect the current tool-call state. */
+    status?: ChatToolState;
+}
+export type ChatToolHeaderProps = ComponentProps<"summary">;
+export type ChatToolStatusProps = ComponentProps<"span">;
+export type ChatToolCallProps = ComponentProps<"div">;
+export type ChatToolResultProps = ComponentProps<"div">;
+export type ChatTypingProps = Omit<ComponentProps<"span">, "children">;
+type ChatPartComponent<T extends HTMLElement, P> = ForwardRefExoticComponent<P & RefAttributes<T>>;
+export type ChatComponent = ChatPartComponent<HTMLDivElement, ChatProps> & {
+    Avatar: ChatPartComponent<HTMLDivElement, ChatAvatarProps>;
+    Header: ChatPartComponent<HTMLDivElement, ChatHeaderProps>;
+    Bubble: ChatPartComponent<HTMLDivElement, ChatBubbleProps>;
+    Footer: ChatPartComponent<HTMLDivElement, ChatFooterProps>;
+    Reasoning: ChatPartComponent<HTMLDetailsElement, ChatReasoningProps>;
+    Tool: ChatPartComponent<HTMLDetailsElement, ChatToolProps>;
+    ToolHeader: ChatPartComponent<HTMLElement, ChatToolHeaderProps>;
+    ToolStatus: ChatPartComponent<HTMLSpanElement, ChatToolStatusProps>;
+    ToolCall: ChatPartComponent<HTMLDivElement, ChatToolCallProps>;
+    ToolResult: ChatPartComponent<HTMLDivElement, ChatToolResultProps>;
+    Typing: ChatPartComponent<HTMLSpanElement, ChatTypingProps>;
+};
+export {};

package/dist/components/chat/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Chat";
+export type * from "./Chat.types";

package/dist/components/chat/index.js

@@ -0,0 +1,220 @@
+"use client";
+
+// src/components/chat/Chat.tsx
+import { forwardRef } from "react";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/chat.ts
+var chatBaseClass = "chat";
+var chatAvatarClass = "chat-avatar";
+var chatHeaderClass = "chat-header";
+var chatBubbleBaseClass = "chat-bubble";
+var chatFooterClass = "chat-footer";
+var chatReasoningClass = "chat-reasoning";
+var chatToolBaseClass = "chat-tool";
+var chatToolHeaderClass = "chat-tool-header";
+var chatToolStatusClass = "chat-tool-status";
+var chatToolCallClass = "chat-tool-call";
+var chatToolResultClass = "chat-tool-result";
+var chatTypingClass = "chat-typing";
+var chatStreamingCaretClass = "chat-streaming-caret";
+var chatBubbleFilledClass = "chat-bubble-filled";
+var chatBubbleStreamingClass = "chat-bubble-streaming";
+var chatPlacementClasses = {
+  start: "chat-start",
+  end: "chat-end"
+};
+var chatBubbleColorClasses = {
+  primary: "chat-bubble-primary",
+  secondary: "chat-bubble-secondary",
+  tertiary: "chat-bubble-tertiary",
+  accent: "chat-bubble-accent",
+  neutral: "chat-bubble-neutral",
+  base: "chat-bubble-base",
+  info: "chat-bubble-info",
+  success: "chat-bubble-success",
+  warning: "chat-bubble-warning",
+  error: "chat-bubble-error"
+};
+var chatBubbleSizeClasses = {
+  xs: "chat-bubble-xs",
+  sm: "chat-bubble-sm",
+  md: "chat-bubble-md",
+  lg: "chat-bubble-lg"
+};
+var chatToolStateClasses = {
+  pending: "chat-tool-pending",
+  running: "chat-tool-running",
+  success: "chat-tool-success",
+  error: "chat-tool-error"
+};
+function getChatClasses({
+  placement = "start",
+  className
+}) {
+  return cn(chatBaseClass, chatPlacementClasses[placement], className);
+}
+function getChatBubbleClasses({
+  color,
+  size = "md",
+  filled,
+  streaming,
+  className
+}) {
+  return cn(chatBubbleBaseClass, color && chatBubbleColorClasses[color], chatBubbleSizeClasses[size], filled && chatBubbleFilledClass, streaming && chatBubbleStreamingClass, className);
+}
+function getChatToolClasses({
+  status,
+  className
+}) {
+  return cn(chatToolBaseClass, status && chatToolStateClasses[status], className);
+}
+
+// src/components/chat/Chat.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var ChatAvatar = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+  ...props,
+  ref,
+  className: cn(chatAvatarClass, className)
+}));
+ChatAvatar.displayName = "Chat.Avatar";
+var ChatHeader = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+  ...props,
+  ref,
+  className: cn(chatHeaderClass, className)
+}));
+ChatHeader.displayName = "Chat.Header";
+var ChatBubble = forwardRef(({ color, size = "md", filled, streaming, className, children, ...props }, ref) => /* @__PURE__ */ jsxs("div", {
+  ...props,
+  ref,
+  className: getChatBubbleClasses({
+    color,
+    size,
+    filled,
+    streaming,
+    className
+  }),
+  children: [
+    children,
+    streaming ? /* @__PURE__ */ jsx("span", {
+      className: chatStreamingCaretClass,
+      "aria-hidden": "true"
+    }) : null
+  ]
+}));
+ChatBubble.displayName = "Chat.Bubble";
+var ChatFooter = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+  ...props,
+  ref,
+  className: cn(chatFooterClass, className)
+}));
+ChatFooter.displayName = "Chat.Footer";
+var ChatReasoning = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("details", {
+  ...props,
+  ref,
+  className: cn(chatReasoningClass, className)
+}));
+ChatReasoning.displayName = "Chat.Reasoning";
+var ChatTool = forwardRef(({ status, className, ...props }, ref) => /* @__PURE__ */ jsx("details", {
+  ...props,
+  ref,
+  className: getChatToolClasses({ status, className })
+}));
+ChatTool.displayName = "Chat.Tool";
+var ChatToolHeader = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("summary", {
+  ...props,
+  ref,
+  className: cn(chatToolHeaderClass, className)
+}));
+ChatToolHeader.displayName = "Chat.ToolHeader";
+var ChatToolStatus = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("span", {
+  ...props,
+  ref,
+  className: cn(chatToolStatusClass, className)
+}));
+ChatToolStatus.displayName = "Chat.ToolStatus";
+var ChatToolCall = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+  ...props,
+  ref,
+  className: cn(chatToolCallClass, className)
+}));
+ChatToolCall.displayName = "Chat.ToolCall";
+var ChatToolResult = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+  ...props,
+  ref,
+  className: cn(chatToolResultClass, className)
+}));
+ChatToolResult.displayName = "Chat.ToolResult";
+var ChatTyping = forwardRef(({
+  className,
+  role = "status",
+  "aria-label": ariaLabel = "Assistant is typing",
+  ...props
+}, ref) => /* @__PURE__ */ jsx("span", {
+  ...props,
+  ref,
+  role,
+  "aria-label": ariaLabel,
+  className: cn(chatTypingClass, className),
+  children: /* @__PURE__ */ jsx("span", {
+    "aria-hidden": "true"
+  })
+}));
+ChatTyping.displayName = "Chat.Typing";
+var ChatRoot = forwardRef(({ placement = "start", className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+  ...props,
+  ref,
+  className: getChatClasses({ placement, className })
+}));
+ChatRoot.displayName = "Chat";
+var Chat = Object.assign(ChatRoot, {
+  Avatar: ChatAvatar,
+  Header: ChatHeader,
+  Bubble: ChatBubble,
+  Footer: ChatFooter,
+  Reasoning: ChatReasoning,
+  Tool: ChatTool,
+  ToolHeader: ChatToolHeader,
+  ToolStatus: ChatToolStatus,
+  ToolCall: ChatToolCall,
+  ToolResult: ChatToolResult,
+  Typing: ChatTyping
+});
+export {
+  Chat,
+  ChatAvatar,
+  ChatBubble,
+  ChatFooter,
+  ChatHeader,
+  ChatReasoning,
+  ChatTool,
+  ChatToolCall,
+  ChatToolHeader,
+  ChatToolResult,
+  ChatToolStatus,
+  ChatTyping
+};

package/dist/components/color-picker/index.js

@@ -88,9 +88,9 @@ function hsbToRgb(value) {
   const c = brightness * s;
   const x = c * (1 - Math.abs(h / 60 % 2 - 1));
   const m = brightness - c;
-  const [r2, g, b] = h < 60 ? [c, x, 0] : h < 120 ? [x, c, 0] : h < 180 ? [0, c, x] : h < 240 ? [0, x, c] : h < 300 ? [x, 0, c] : [c, 0, x];
+  const [r, g, b] = h < 60 ? [c, x, 0] : h < 120 ? [x, c, 0] : h < 180 ? [0, c, x] : h < 240 ? [0, x, c] : h < 300 ? [x, 0, c] : [c, 0, x];
   return {
-    r: (r2 + m) * 255,
+    r: (r + m) * 255,
     g: (g + m) * 255,
     b: (b + m) * 255,
     a: value.a
@@ -113,8 +113,8 @@ function colorToRgb(value) {
   }
   const match = normalized.match(/rgba?\(([^)]+)\)/i);
   if (match) {
-    const [r2, g, b, a] = match[1].split(",").map((part) => Number(part.trim()));
-    return { r: r2, g, b, a };
+    const [r, g, b, a] = match[1].split(",").map((part) => Number(part.trim()));
+    return { r, g, b, a };
   }
   return { r: 0, g: 0, b: 0 };
 }

package/dist/components/config-provider/index.js

@@ -122,6 +122,6 @@ ConfigProvider.config = (config) => {
   globalConfig = { ...globalConfig, ...config };
 };
 export {
-  ConfigProvider,
-  ConfigContext
+  ConfigContext,
+  ConfigProvider
 };