@ant-design/agentic-ui 2.0.22 → 2.0.23

package/dist/Components/GradientText/index.d.ts

@@ -4,5 +4,6 @@ export interface GradientTextProps {
     className?: string;
     colors?: string[];
     animationSpeed?: number;
+    style?: React.CSSProperties;
 }
-export declare function GradientText({ children, className, colors, animationSpeed, }: GradientTextProps): React.JSX.Element;
+export declare function GradientText({ children, className, colors, animationSpeed, style, }: GradientTextProps): React.JSX.Element;

package/dist/Components/GradientText/index.js

@@ -7,7 +7,8 @@ function GradientText({
   children,
   className = "",
   colors = ["#40ffaa", "#4079ff", "#40ffaa", "#4079ff", "#40ffaa"],
-  animationSpeed = 8
+  animationSpeed = 8,
+  style
 }) {
   const { getPrefixCls } = useContext(ConfigProvider.ConfigContext);
   const prefixCls = getPrefixCls("gradient-text");
@@ -17,7 +18,7 @@ function GradientText({
     animationDuration: `${animationSpeed}s`
   };
   return wrapSSR(
-    /* @__PURE__ */ React.createElement("div", { className: classNames(prefixCls, hashId, className) }, /* @__PURE__ */ React.createElement(
+    /* @__PURE__ */ React.createElement("div", { className: classNames(prefixCls, hashId, className), style }, /* @__PURE__ */ React.createElement(
       "div",
       {
         className: classNames(`${prefixCls}-text-content`, hashId),

package/dist/Components/GradientText/style.js

@@ -25,13 +25,10 @@ import {
 } from "../../Hooks/useStyle";
 var animateGradientText = new Keyframes("animateGradientText", {
   "0%": {
-    backgroundPosition: "0% 50%"
-  },
-  "50%": {
-    backgroundPosition: "100% 50%"
+    backgroundPosition: "100%"
   },
   "100%": {
-    backgroundPosition: "0% 50%"
+    backgroundPosition: "-100%"
   }
 });
 var genStyle = (token) => {
@@ -45,14 +42,12 @@ var genStyle = (token) => {
       alignItems: "center",
       justifyContent: "center",
       fontWeight: 500,
-      backdropFilter: "blur(10px)",
-      transition: "box-shadow 0.5s ease-out",
       overflow: "hidden",
       ["&-text-content"]: {
         display: "inline-block",
         position: "relative",
         zIndex: 2,
-        backgroundSize: "300% 100%",
+        backgroundSize: "200% 100%",
         backgroundClip: "text",
         WebkitBackgroundClip: "text",
         color: "transparent",

package/dist/Components/TextAnimate/index.d.ts

@@ -52,5 +52,6 @@ export interface TextAnimateProps extends MotionProps {
      */
     accessible?: boolean;
 }
+export declare const resolveSegments: (children: React.ReactNode, by: AnimationType) => React.ReactNode[];
 export declare const TextAnimate: React.MemoExoticComponent<({ children, delay, duration, variants, className, segmentClassName, as: Component, startOnView, once, by, animation, accessible, ...props }: TextAnimateProps) => React.JSX.Element>;
 export {};

package/dist/Components/TextAnimate/index.js

@@ -34,7 +34,7 @@ var __objRest = (source, exclude) => {
 import { ConfigProvider } from "antd";
 import classNames from "classnames";
 import { AnimatePresence, motion } from "framer-motion";
-import { isString } from "lodash";
+import { isNumber, isObject, isString } from "lodash";
 import toArray from "rc-util/lib/Children/toArray";
 import React, { memo, useContext } from "react";
 import { useTextAnimateStyle } from "./style";
@@ -266,19 +266,29 @@ var defaultItemAnimationVariants = {
   }
 };
 var resolveSegments = (children, by) => {
-  if (!isString(children))
-    return toArray(children);
-  switch (by) {
-    case "word":
-      return children.split(/(\s+)/);
-    case "character":
-      return children.split("");
-    case "line":
-      return children.split("\n");
-    case "text":
-    default:
-      return [children];
-  }
+  const result = [];
+  toArray(children).forEach((item) => {
+    if (isString(item) || isNumber(item)) {
+      const itemString = item.toString();
+      switch (by) {
+        case "word":
+          result.push(...itemString.split(/(\s+)/));
+          break;
+        case "character":
+          result.push(...itemString.split(""));
+          break;
+        case "line":
+          result.push(...itemString.split("\n"));
+          break;
+        case "text":
+        default:
+          result.push(itemString);
+      }
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
 };
 var TextAnimateBase = (_a) => {
   var _b = _a, {
@@ -367,7 +377,7 @@ var TextAnimateBase = (_a) => {
       segments.map((segment, i) => /* @__PURE__ */ React.createElement(
         motion.span,
         {
-          key: `${by}-${isString(segment) ? segment : segment == null ? void 0 : segment.key}-${i}`,
+          key: `${by}-${isObject(segment) ? segment.key : segment}-${i}`,
           variants: finalVariants.item,
           custom: i * staggerTimings[by],
           className: classNames(
@@ -384,5 +394,6 @@ var TextAnimateBase = (_a) => {
 };
 var TextAnimate = memo(TextAnimateBase);
 export {
-  TextAnimate
+  TextAnimate,
+  resolveSegments
 };

package/dist/Components/TypingAnimation/index.d.ts

@@ -1,7 +1,7 @@
 import { MotionProps } from 'framer-motion';
 import React from 'react';
 export interface TypingAnimationProps extends MotionProps {
-    children?: string;
+    children?: React.ReactNode;
     words?: string[];
     className?: string;
     duration?: number;

package/dist/Components/TypingAnimation/index.js

@@ -31,7 +31,9 @@ var __objRest = (source, exclude) => {
 import { ConfigProvider } from "antd";
 import classNames from "classnames";
 import { motion, useInView } from "framer-motion";
+import { isString } from "lodash";
 import React, { useContext, useEffect, useMemo, useRef, useState } from "react";
+import { resolveSegments } from "../TextAnimate";
 import { useTypingAnimationStyle } from "./style";
 function TypingAnimation(_a) {
   var _b = _a, {
@@ -71,7 +73,7 @@ function TypingAnimation(_a) {
   const { getPrefixCls } = useContext(ConfigProvider.ConfigContext);
   const prefixCls = getPrefixCls("typing-animation");
   const { wrapSSR, hashId } = useTypingAnimationStyle(prefixCls);
-  const [displayedText, setDisplayedText] = useState("");
+  const [displayedText, setDisplayedText] = useState([]);
   const [currentWordIndex, setCurrentWordIndex] = useState(0);
   const [currentCharIndex, setCurrentCharIndex] = useState(0);
   const [phase, setPhase] = useState("typing");
@@ -81,7 +83,7 @@ function TypingAnimation(_a) {
     once: true
   });
   const wordsToAnimate = useMemo(
-    () => words || (children ? [children] : []),
+    () => words || [resolveSegments(children, "character")],
     [words, children]
   );
   const hasMultipleWords = wordsToAnimate.length > 1;
@@ -91,14 +93,14 @@ function TypingAnimation(_a) {
   useEffect(() => {
     if (!shouldStart || wordsToAnimate.length === 0)
       return;
-    const timeoutDelay = delay > 0 && displayedText === "" ? delay : phase === "typing" ? typingSpeed : phase === "deleting" ? deletingSpeed : pauseDelay;
+    const timeoutDelay = delay > 0 && displayedText.length === 0 ? delay : phase === "typing" ? typingSpeed : phase === "deleting" ? deletingSpeed : pauseDelay;
     const timeout = setTimeout(() => {
       const currentWord = wordsToAnimate[currentWordIndex] || "";
-      const graphemes = Array.from(currentWord);
+      const graphemes = isString(currentWord) ? Array.from(currentWord) : currentWord;
       switch (phase) {
         case "typing":
           if (currentCharIndex < graphemes.length) {
-            setDisplayedText(graphemes.slice(0, currentCharIndex + 1).join(""));
+            setDisplayedText(graphemes.slice(0, currentCharIndex + 1));
             setCurrentCharIndex(currentCharIndex + 1);
           } else {
             if (hasMultipleWords || loop) {
@@ -114,7 +116,7 @@ function TypingAnimation(_a) {
           break;
         case "deleting":
           if (currentCharIndex > 0) {
-            setDisplayedText(graphemes.slice(0, currentCharIndex - 1).join(""));
+            setDisplayedText(graphemes.slice(0, currentCharIndex - 1));
             setCurrentCharIndex(currentCharIndex - 1);
           } else {
             const nextIndex = (currentWordIndex + 1) % wordsToAnimate.length;
@@ -139,9 +141,7 @@ function TypingAnimation(_a) {
     pauseDelay,
     delay
   ]);
-  const currentWordGraphemes = Array.from(
-    wordsToAnimate[currentWordIndex] || ""
-  );
+  const currentWordGraphemes = isString(wordsToAnimate[currentWordIndex]) ? Array.from(wordsToAnimate[currentWordIndex]) : [wordsToAnimate[currentWordIndex]];
   const isComplete = !loop && currentWordIndex === wordsToAnimate.length - 1 && currentCharIndex >= currentWordGraphemes.length && phase !== "deleting";
   const shouldShowCursor = showCursor && !isComplete && (hasMultipleWords || loop || currentCharIndex < currentWordGraphemes.length);
   const getCursorChar = () => {

package/dist/MarkdownEditor/editor/components/LazyElement/index.js

@@ -29,18 +29,28 @@ var LazyElement = ({
   const [isVisible, setIsVisible] = useState(false);
   const [hasRendered, setHasRendered] = useState(false);
   const [isIntersecting, setIsIntersecting] = useState(false);
+  const observerRef = useRef(null);
   useEffect(() => {
     const container = containerRef.current;
     if (!container)
       return;
+    if (hasRendered)
+      return;
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+      observerRef.current = null;
+    }
     const observer = new IntersectionObserver(
       (entries) => {
         entries.forEach((entry) => {
           setIsIntersecting(entry.isIntersecting);
-          if (entry.isIntersecting) {
+          if (entry.isIntersecting && !hasRendered) {
             setIsVisible(true);
             setHasRendered(true);
-            observer.disconnect();
+            if (observerRef.current) {
+              observerRef.current.disconnect();
+              observerRef.current = null;
+            }
           }
         });
       },
@@ -49,11 +59,33 @@ var LazyElement = ({
         threshold: 0
       }
     );
+    observerRef.current = observer;
     observer.observe(container);
+    const timeoutId = setTimeout(() => {
+      const rect = container.getBoundingClientRect();
+      const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+      const windowWidth = window.innerWidth || document.documentElement.clientWidth;
+      if (!hasRendered && (rect.height > 0 || rect.width > 0) && windowHeight > 0 && windowWidth > 0) {
+        const margin = parseInt(rootMargin) || 200;
+        const isInViewport = rect.top < windowHeight + margin && rect.bottom > -margin && rect.left < windowWidth + margin && rect.right > -margin;
+        if (isInViewport) {
+          setIsVisible(true);
+          setHasRendered(true);
+          if (observerRef.current) {
+            observerRef.current.disconnect();
+            observerRef.current = null;
+          }
+        }
+      }
+    }, 100);
     return () => {
-      observer.disconnect();
+      clearTimeout(timeoutId);
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
     };
-  }, [rootMargin]);
+  }, [rootMargin, hasRendered]);
   if (hasRendered || isVisible) {
     return /* @__PURE__ */ React.createElement("div", { ref: containerRef }, children);
   }

package/dist/MarkdownEditor/editor/parser/parserMarkdownToSlateNode.d.ts

@@ -1,3 +1,7 @@
+/**
+ * 此文件包含大量相互依赖的函数，为了保持代码的可读性和逻辑分组，
+ * 我们允许函数在定义前使用（函数提升）
+ */
 import { Elements } from '../../el';
 import { MarkdownEditorPlugin } from '../../plugin';
 export declare const decodeURIComponentUrl: (url: string) => string;