@ant-design/agentic-ui 2.0.10 → 2.0.13

package/dist/Components/lotties/ThinkingLottie/index.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/Components/lotties/ThinkingLottie/index.tsx
+import Lottie from "lottie-react";
+import React from "react";
+import thinkingLottie from "./thinking.json";
+var ThinkingLottie = ({
+  autoplay = true,
+  loop = true,
+  className,
+  style,
+  size
+}) => {
+  const containerStyle = __spreadValues({
+    width: size,
+    height: size,
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center"
+  }, style);
+  return /* @__PURE__ */ React.createElement(
+    Lottie,
+    {
+      style: containerStyle,
+      className,
+      "aria-hidden": "true",
+      animationData: thinkingLottie,
+      loop,
+      autoplay
+    }
+  );
+};
+var ThinkingLottie_default = ThinkingLottie;
+export {
+  ThinkingLottie,
+  ThinkingLottie_default as default
+};

package/dist/Components/lotties/index.js

@@ -0,0 +1,3 @@
+// src/Components/lotties/index.ts
+export * from "./DazingLottie";
+export * from "./ThinkingLottie";

package/dist/Constants/colors.js

@@ -0,0 +1,98 @@
+// src/Constants/colors.ts
+var COLORS = {
+  // 蓝色系
+  blue: {
+    primary: "#1677ff",
+    light: "#D6EEFF",
+    border: "#E6ECF4",
+    dark: "#19213D",
+    contrast: "#FFFFFF"
+  },
+  // 灰色系
+  gray: {
+    text: "#343A45",
+    light: "#FBFCFD",
+    border: "#E6ECF4",
+    background: "#f0f0f0",
+    card: "#FFFFFF"
+  },
+  // 红色系
+  red: {
+    error: "#FF4141",
+    light: "#FFEDEC",
+    border: "#f97583",
+    background: "#ffeaea"
+  },
+  // 绿色系
+  green: {
+    success: "#52c41a",
+    light: "#f6ffed",
+    dark: "#00B341"
+  },
+  // 橙色系
+  orange: {
+    warning: "#faad14",
+    light: "#fff7e6",
+    border: "#ffd591"
+  },
+  // 状态颜色
+  status: {
+    info: "#1890ff",
+    success: "#52c41a",
+    warning: "#faad14",
+    error: "#ff4d4f",
+    processing: "#1890ff"
+  },
+  // 边框颜色
+  border: {
+    light: "#E6ECF4",
+    default: "#d9d9d9",
+    dark: "#bfbfbf"
+  },
+  // 背景颜色
+  background: {
+    light: "#FBFCFD",
+    default: "#FFFFFF",
+    dark: "#f5f5f5",
+    error: "#FFEDEC",
+    success: "#f6ffed",
+    warning: "#fff7e6"
+  }
+};
+var { blue, gray, red, green, orange, status, border, background } = COLORS;
+var {
+  primary: PRIMARY_COLOR,
+  light: LIGHT_BLUE,
+  border: BORDER_COLOR,
+  dark: DARK_BLUE,
+  contrast: CONTRAST_COLOR
+} = blue;
+var { text: TEXT_COLOR, light: LIGHT_GRAY, card: CARD_COLOR } = gray;
+var { error: ERROR_COLOR, light: ERROR_LIGHT } = red;
+var { success: SUCCESS_COLOR, light: SUCCESS_LIGHT } = green;
+var { warning: WARNING_COLOR, light: WARNING_LIGHT } = orange;
+export {
+  BORDER_COLOR,
+  CARD_COLOR,
+  COLORS,
+  CONTRAST_COLOR,
+  DARK_BLUE,
+  ERROR_COLOR,
+  ERROR_LIGHT,
+  LIGHT_BLUE,
+  LIGHT_GRAY,
+  PRIMARY_COLOR,
+  SUCCESS_COLOR,
+  SUCCESS_LIGHT,
+  TEXT_COLOR,
+  WARNING_COLOR,
+  WARNING_LIGHT,
+  background,
+  blue,
+  border,
+  gray,
+  green,
+  orange,
+  red,
+  status
+};

package/dist/History/components/HistoryActionsBox.js

@@ -23,7 +23,7 @@ var __async = (__this, __arguments, generator) => {
 import { Star, StarFill, Trash2 } from "@sofa-design/icons";
 import { ConfigProvider, Popconfirm, Space } from "antd";
 import React, { useContext, useState } from "react";
-import { I18nContext } from "../../i18n";
+import { I18nContext } from "../../I18n";
 import { ActionIconBox } from "../../index";
 var HistoryActionsBox = (props) => {
   var _a, _b, _c, _d, _e, _f, _g;

package/dist/History/components/HistoryItem.js

@@ -43,7 +43,7 @@ import {
 } from "@sofa-design/icons";
 import { Checkbox, ConfigProvider, Divider, Tooltip } from "antd";
 import React, { useContext } from "react";
-import { I18nContext } from "../../i18n";
+import { I18nContext } from "../../I18n";
 import { useStyle } from "../style";
 import {
   TaskStatusData

package/dist/History/components/LoadMoreComponent.js

@@ -38,8 +38,8 @@ var __async = (__this, __arguments, generator) => {
 // src/History/components/LoadMoreComponent.tsx
 import { EllipsisOutlined, LoadingOutlined } from "@ant-design/icons";
 import React, { useCallback, useContext, useState } from "react";
-import { useRefFunction } from "../../hooks/useRefFunction";
-import { I18nContext } from "../../i18n";
+import { useRefFunction } from "../../Hooks/useRefFunction";
+import { I18nContext } from "../../I18n";
 var MoreTaskIcon = (props) => {
   return /* @__PURE__ */ React.createElement(
     "svg",

package/dist/History/components/NewChatComponent.js

@@ -23,7 +23,7 @@ var __async = (__this, __arguments, generator) => {
 import { AiAgentManagement } from "@sofa-design/icons";
 import { ConfigProvider } from "antd";
 import React, { useCallback, useContext, useState } from "react";
-import { I18nContext } from "../../i18n";
+import { I18nContext } from "../../I18n";
 import { useNewChatStyle } from "./NewChatComponent.style";
 var HistoryNewChat = ({
   onNewChat,

package/dist/History/components/NewChatComponent.style.js

@@ -21,7 +21,7 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 // src/History/components/NewChatComponent.style.ts
 import {
   useEditorStyleRegister
-} from "../../hooks/useStyle";
+} from "../../Hooks/useStyle";
 var genNewChatStyle = (token) => {
   return {
     [`${token.componentCls}-new-chat`]: {

package/dist/History/components/SearchComponent.js

@@ -38,10 +38,10 @@ var __async = (__this, __arguments, generator) => {
 // src/History/components/SearchComponent.tsx
 import { Input, Spin } from "antd";
 import React, { useContext, useRef, useState } from "react";
-import { ActionIconBox } from "../../components/ActionIconBox";
-import useClickAway from "../../hooks/useClickAway";
-import { useDebounceFn } from "../../hooks/useDebounceFn";
-import { I18nContext } from "../../i18n";
+import { ActionIconBox } from "../../Components/ActionIconBox";
+import useClickAway from "../../Hooks/useClickAway";
+import { useDebounceFn } from "../../Hooks/useDebounceFn";
+import { I18nContext } from "../../I18n";
 function SearchIcon(props) {
   return /* @__PURE__ */ React.createElement(
     "svg",

package/dist/History/index.js

@@ -23,7 +23,7 @@ var __async = (__this, __arguments, generator) => {
 import { History as HistoryIcon } from "@sofa-design/icons";
 import { ConfigProvider, Popover } from "antd";
 import React, { useContext, useRef } from "react";
-import useClickAway from "../hooks/useClickAway";
+import useClickAway from "../Hooks/useClickAway";
 import { ActionIconBox, BubbleConfigContext } from "../index";
 import {
   HistoryLoadMore,

package/dist/History/style.js

@@ -21,7 +21,7 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 // src/History/style.ts
 import {
   useEditorStyleRegister
-} from "../hooks/useStyle";
+} from "../Hooks/useStyle";
 var genStyle = (token) => {
   return {
     [`${token.componentCls}-load-more`]: {

package/dist/Hooks/useAutoScroll.js

@@ -0,0 +1,90 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Hooks/useAutoScroll.tsx
+import { useEffect, useRef } from "react";
+import { useThrottleFn } from "./useThrottleFn";
+var SCROLL_TOLERANCE = 20;
+var useAutoScroll = (props = {
+  SCROLL_TOLERANCE
+}) => {
+  const containerRef = useRef(null);
+  const lastScrollHeight = useRef(0);
+  const isLocked = useRef(false);
+  const observer = useRef(null);
+  const _checkScroll = (force = false) => __async(void 0, null, function* () {
+    var _a, _b;
+    const container = containerRef.current;
+    if (!container)
+      return;
+    (_a = props.onResize) == null ? void 0 : _a.call(props, {
+      width: container.clientWidth,
+      height: container.clientHeight
+    });
+    const currentScrollHeight = container.scrollHeight;
+    const prevScrollHeight = lastScrollHeight.current;
+    const isNearBottom = container.scrollTop + container.clientHeight >= prevScrollHeight - ((props == null ? void 0 : props.SCROLL_TOLERANCE) || SCROLL_TOLERANCE);
+    const shouldScroll = force || currentScrollHeight > prevScrollHeight && (isNearBottom || isLocked.current);
+    if (shouldScroll && container.scrollTo) {
+      (_b = container.scrollTo) == null ? void 0 : _b.call(container, {
+        top: currentScrollHeight,
+        behavior: "smooth"
+      });
+      isLocked.current = false;
+    }
+    lastScrollHeight.current = currentScrollHeight;
+  });
+  const checkScroll = useThrottleFn(_checkScroll, props.timeout || 160);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container)
+      return;
+    observer.current = new MutationObserver((mutations) => {
+      const hasAddedNodes = mutations.some((m) => m.addedNodes.length > 0);
+      if (hasAddedNodes)
+        checkScroll == null ? void 0 : checkScroll();
+    });
+    observer.current.observe(container, {
+      childList: true,
+      // 监听子元素变化
+      subtree: true,
+      // 监听所有后代
+      attributes: false,
+      characterData: false
+    });
+    return () => {
+      var _a;
+      return (_a = observer.current) == null ? void 0 : _a.disconnect();
+    };
+  }, [...props.deps || []]);
+  const scrollToBottom = () => {
+    checkScroll == null ? void 0 : checkScroll(true);
+  };
+  return {
+    containerRef,
+    scrollToBottom
+  };
+};
+var useAutoScroll_default = useAutoScroll;
+export {
+  useAutoScroll_default as default,
+  useAutoScroll
+};

package/dist/Hooks/useClickAway.js

@@ -0,0 +1,23 @@
+// src/Hooks/useClickAway.ts
+import { useEffect } from "react";
+var EVENT = "mousedown";
+var useClickAway = (callback, ref) => {
+  useEffect(() => {
+    const listener = (event) => {
+      var _a;
+      if (!ref || !ref.current || ref.current.contains(event.target) || ((_a = ref.current.parentNode) == null ? void 0 : _a.contains(event.target))) {
+        return;
+      }
+      callback(event);
+    };
+    document.addEventListener(EVENT, listener);
+    return () => {
+      document.removeEventListener(EVENT, listener);
+    };
+  }, [ref, callback]);
+};
+var useClickAway_default = useClickAway;
+export {
+  useClickAway_default as default,
+  useClickAway
+};

package/dist/Hooks/useCopied.js

@@ -0,0 +1,22 @@
+// src/Hooks/useCopied.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+var useCopied = () => {
+  const [copied, setCopy] = useState(false);
+  useEffect(() => {
+    if (!copied)
+      return;
+    const timer = setTimeout(() => {
+      setCopy(false);
+    }, 1e3);
+    return () => {
+      if (typeof clearTimeout !== "undefined") {
+        clearTimeout(timer);
+      }
+    };
+  }, [copied]);
+  const setCopied = useCallback(() => setCopy(true), []);
+  return useMemo(() => ({ copied, setCopied }), [copied]);
+};
+export {
+  useCopied
+};

package/dist/Hooks/useDebounceFn/index.js

@@ -0,0 +1,59 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Hooks/useDebounceFn/index.ts
+import { useCallback, useEffect, useRef } from "react";
+import { useRefFunction } from "../useRefFunction";
+function useDebounceFn(fn, wait) {
+  const callback = useRefFunction(fn);
+  const timer = useRef();
+  const cancel = useCallback(() => {
+    if (timer.current) {
+      clearTimeout(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  const run = useCallback(
+    (...args) => __async(this, null, function* () {
+      if (wait === 0 || wait === void 0) {
+        return callback(...args);
+      }
+      cancel();
+      return new Promise((resolve) => {
+        timer.current = setTimeout(() => __async(this, null, function* () {
+          resolve(yield callback(...args));
+          return;
+        }), wait);
+      });
+    }),
+    [callback, cancel, wait]
+  );
+  useEffect(() => {
+    return cancel;
+  }, [cancel]);
+  return {
+    run,
+    cancel
+  };
+}
+export {
+  useDebounceFn
+};

package/dist/Hooks/useLanguage.js

@@ -0,0 +1,29 @@
+// src/Hooks/useLanguage.ts
+import { useCallback, useContext } from "react";
+import { I18nContext } from "../I18n";
+function useLanguage() {
+  const context = useContext(I18nContext);
+  if (!context) {
+    throw new Error("useLanguage must be used within I18nProvide");
+  }
+  const { language, locale, setLanguage } = context;
+  const toggleLanguage = useCallback(() => {
+    const newLanguage = language === "zh-CN" ? "en-US" : "zh-CN";
+    setLanguage == null ? void 0 : setLanguage(newLanguage);
+  }, [language, setLanguage]);
+  const isChinese = language === "zh-CN";
+  const isEnglish = language === "en-US";
+  return {
+    language,
+    locale,
+    setLanguage,
+    toggleLanguage,
+    isChinese,
+    isEnglish
+  };
+}
+var useLanguage_default = useLanguage;
+export {
+  useLanguage_default as default,
+  useLanguage
+};

package/dist/Hooks/useRefFunction/index.js

@@ -0,0 +1,13 @@
+// src/Hooks/useRefFunction/index.ts
+import { useCallback, useRef } from "react";
+var useRefFunction = (reFunction) => {
+  const ref = useRef(null);
+  ref.current = reFunction;
+  return useCallback((...rest) => {
+    var _a;
+    return (_a = ref.current) == null ? void 0 : _a.call(ref, ...rest);
+  }, []);
+};
+export {
+  useRefFunction
+};

package/dist/Hooks/useSpeechSynthesis.js

@@ -0,0 +1,108 @@
+// src/Hooks/useSpeechSynthesis.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var useSpeechSynthesis = (options) => {
+  const { text, defaultRate = 1 } = options;
+  const isSupported = useMemo(
+    () => typeof window !== "undefined" && !!window.speechSynthesis,
+    []
+  );
+  const [rate, setRate] = useState(defaultRate);
+  const [isPlaying, setIsPlaying] = useState(false);
+  const utterRef = useRef(null);
+  const stop = useCallback(() => {
+    if (!isSupported)
+      return;
+    try {
+      if (utterRef.current) {
+        utterRef.current.onend = null;
+        utterRef.current.onerror = null;
+      }
+      window.speechSynthesis.cancel();
+    } catch (e) {
+    }
+    utterRef.current = null;
+    setIsPlaying(false);
+  }, [isSupported]);
+  const start = useCallback(() => {
+    if (!isSupported)
+      return;
+    if (!text)
+      return;
+    try {
+      if (utterRef.current) {
+        utterRef.current.onend = null;
+        utterRef.current.onerror = null;
+      }
+      window.speechSynthesis.cancel();
+      const utter = new SpeechSynthesisUtterance(text);
+      utter.rate = rate;
+      utterRef.current = utter;
+      utter.onend = () => {
+        setIsPlaying(false);
+        utterRef.current = null;
+      };
+      utter.onerror = () => {
+        setIsPlaying(false);
+        utterRef.current = null;
+      };
+      window.speechSynthesis.speak(utter);
+      setIsPlaying(true);
+    } catch (e) {
+      setIsPlaying(false);
+    }
+  }, [isSupported, text, rate]);
+  const pause = useCallback(() => {
+    if (!isSupported)
+      return;
+    try {
+      window.speechSynthesis.pause();
+    } catch (e) {
+    }
+  }, [isSupported]);
+  const resume = useCallback(() => {
+    if (!isSupported)
+      return;
+    try {
+      window.speechSynthesis.resume();
+    } catch (e) {
+    }
+  }, [isSupported]);
+  useEffect(() => {
+    if (!isSupported)
+      return;
+    if (!isPlaying)
+      return;
+    start();
+  }, [rate]);
+  useEffect(() => {
+    if (!isSupported)
+      return;
+    return () => {
+      if (utterRef.current) {
+        try {
+          utterRef.current.onend = null;
+          utterRef.current.onerror = null;
+          window.speechSynthesis.cancel();
+        } catch (e) {
+        }
+        utterRef.current = null;
+      }
+      setIsPlaying(false);
+    };
+  }, [isSupported]);
+  return {
+    isSupported,
+    isPlaying,
+    rate,
+    setRate,
+    start,
+    stop,
+    pause,
+    resume
+  };
+};
+var useSpeechSynthesis_default = useSpeechSynthesis;
+export {
+  useSpeechSynthesis_default as default,
+  useSpeechSynthesis
+};

package/dist/Hooks/useStyle/index.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/Hooks/useStyle/index.tsx
+import {
+  createStyleRegister,
+  globalThemeToken
+} from "@ant-design/theme-token";
+import { ConfigProvider as AntdConfigProvider, theme as antdTheme } from "antd";
+import { useContext } from "react";
+var resetComponent = (token) => ({
+  [`${token.componentCls}`]: {
+    boxSizing: "border-box",
+    margin: 0,
+    padding: 0,
+    color: token.colorText,
+    fontSize: "1em",
+    lineHeight: token.lineHeight,
+    listStyle: "none",
+    "svg.sofa-icons-icon > g": {
+      clipPath: "none!important"
+    }
+  }
+});
+function useEditorStyleRegister(componentName, styleFn) {
+  var _a, _b;
+  const { token, hashId, theme } = ((_b = (_a = antdTheme) == null ? void 0 : _a.useToken) == null ? void 0 : _b.call(_a)) || {};
+  const chatToken = __spreadProps(__spreadValues({}, token), {
+    chatCls: "",
+    antCls: ""
+  });
+  const { getPrefixCls } = useContext(AntdConfigProvider.ConfigContext);
+  chatToken.chatCls = `.${getPrefixCls("agentic-ui")}`;
+  chatToken.antCls = `.${getPrefixCls()}`;
+  const genStyles = createStyleRegister({
+    hashId: hashId || "",
+    token: chatToken,
+    theme,
+    cssVariables: globalThemeToken
+  });
+  const result = genStyles(componentName, styleFn);
+  return result || { wrapSSR: (node) => node, hashId: "" };
+}
+export {
+  resetComponent,
+  useEditorStyleRegister
+};