@ant-design/agentic-ui 2.8.0 → 2.10.0

package/dist/Utils/proxySandbox/types.js

@@ -1,52 +1,187 @@
-// src/Utils/proxySandbox/types.ts
-var SandboxErrorType = /* @__PURE__ */ ((SandboxErrorType2) => {
-  SandboxErrorType2["TIMEOUT"] = "TIMEOUT";
-  SandboxErrorType2["MEMORY_LIMIT"] = "MEMORY_LIMIT";
-  SandboxErrorType2["FORBIDDEN_ACCESS"] = "FORBIDDEN_ACCESS";
-  SandboxErrorType2["SYNTAX_ERROR"] = "SYNTAX_ERROR";
-  SandboxErrorType2["RUNTIME_ERROR"] = "RUNTIME_ERROR";
-  SandboxErrorType2["SECURITY_VIOLATION"] = "SECURITY_VIOLATION";
-  SandboxErrorType2["RESOURCE_LIMIT"] = "RESOURCE_LIMIT";
-  return SandboxErrorType2;
-})(SandboxErrorType || {});
-var SandboxError = class extends Error {
-  constructor(message, type, context) {
-    super(message);
-    this.name = "SandboxError";
-    this.type = type;
-    this.context = context;
-    this.timestamp = Date.now();
-  }
-};
-var ExecutionStatus = /* @__PURE__ */ ((ExecutionStatus2) => {
-  ExecutionStatus2["PENDING"] = "PENDING";
-  ExecutionStatus2["RUNNING"] = "RUNNING";
-  ExecutionStatus2["SUCCESS"] = "SUCCESS";
-  ExecutionStatus2["FAILED"] = "FAILED";
-  ExecutionStatus2["CANCELLED"] = "CANCELLED";
-  ExecutionStatus2["TIMEOUT"] = "TIMEOUT";
-  return ExecutionStatus2;
-})(ExecutionStatus || {});
-var PermissionLevel = /* @__PURE__ */ ((PermissionLevel2) => {
-  PermissionLevel2["NONE"] = "NONE";
-  PermissionLevel2["READ_ONLY"] = "READ_ONLY";
-  PermissionLevel2["LIMITED"] = "LIMITED";
-  PermissionLevel2["FULL"] = "FULL";
-  return PermissionLevel2;
-})(PermissionLevel || {});
-var MonitoringEventType = /* @__PURE__ */ ((MonitoringEventType2) => {
-  MonitoringEventType2["EXECUTION_START"] = "EXECUTION_START";
-  MonitoringEventType2["EXECUTION_END"] = "EXECUTION_END";
-  MonitoringEventType2["MEMORY_USAGE"] = "MEMORY_USAGE";
-  MonitoringEventType2["PERFORMANCE_WARNING"] = "PERFORMANCE_WARNING";
-  MonitoringEventType2["SECURITY_EVENT"] = "SECURITY_EVENT";
-  MonitoringEventType2["ERROR_EVENT"] = "ERROR_EVENT";
-  return MonitoringEventType2;
-})(MonitoringEventType || {});
-export {
-  ExecutionStatus,
-  MonitoringEventType,
-  PermissionLevel,
-  SandboxError,
-  SandboxErrorType
-};
+/**
+ * 沙箱模块的 TypeScript 类型定义
+ *
+ * 提供完整的类型定义，确保类型安全和良好的开发体验。
+ *
+ * @author md-editor
+ * @version 1.0.0
+ */ /**
+ * 沙箱错误类型枚举
+ */ function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+export var SandboxErrorType = /*#__PURE__*/ function(SandboxErrorType) {
+    /** 代码执行超时 */ SandboxErrorType["TIMEOUT"] = "TIMEOUT";
+    /** 内存超限 */ SandboxErrorType["MEMORY_LIMIT"] = "MEMORY_LIMIT";
+    /** 访问被禁止的全局对象 */ SandboxErrorType["FORBIDDEN_ACCESS"] = "FORBIDDEN_ACCESS";
+    /** 语法错误 */ SandboxErrorType["SYNTAX_ERROR"] = "SYNTAX_ERROR";
+    /** 运行时错误 */ SandboxErrorType["RUNTIME_ERROR"] = "RUNTIME_ERROR";
+    /** 安全违规 */ SandboxErrorType["SECURITY_VIOLATION"] = "SECURITY_VIOLATION";
+    /** 资源限制 */ SandboxErrorType["RESOURCE_LIMIT"] = "RESOURCE_LIMIT";
+    return SandboxErrorType;
+}({});
+/**
+ * 沙箱错误类
+ */ export var SandboxError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(SandboxError, Error1);
+    function SandboxError(message, type, context) {
+        _class_call_check(this, SandboxError);
+        var _this;
+        _this = _call_super(this, SandboxError, [
+            message
+        ]), _define_property(_this, "type", void 0), _define_property(_this, "context", void 0), _define_property(_this, "timestamp", void 0);
+        _this.name = 'SandboxError';
+        _this.type = type;
+        _this.context = context;
+        _this.timestamp = Date.now();
+        return _this;
+    }
+    return SandboxError;
+}(_wrap_native_super(Error));
+/**
+ * 代码执行状态枚举
+ */ export var ExecutionStatus = /*#__PURE__*/ function(ExecutionStatus) {
+    /** 准备中 */ ExecutionStatus["PENDING"] = "PENDING";
+    /** 执行中 */ ExecutionStatus["RUNNING"] = "RUNNING";
+    /** 执行成功 */ ExecutionStatus["SUCCESS"] = "SUCCESS";
+    /** 执行失败 */ ExecutionStatus["FAILED"] = "FAILED";
+    /** 已取消 */ ExecutionStatus["CANCELLED"] = "CANCELLED";
+    /** 超时 */ ExecutionStatus["TIMEOUT"] = "TIMEOUT";
+    return ExecutionStatus;
+}({});
+/**
+ * 权限级别枚举
+ */ export var PermissionLevel = /*#__PURE__*/ function(PermissionLevel) {
+    /** 无权限 */ PermissionLevel["NONE"] = "NONE";
+    /** 只读权限 */ PermissionLevel["READ_ONLY"] = "READ_ONLY";
+    /** 受限权限 */ PermissionLevel["LIMITED"] = "LIMITED";
+    /** 完全权限 */ PermissionLevel["FULL"] = "FULL";
+    return PermissionLevel;
+}({});
+/**
+ * 监控事件类型
+ */ export var MonitoringEventType = /*#__PURE__*/ function(MonitoringEventType) {
+    /** 执行开始 */ MonitoringEventType["EXECUTION_START"] = "EXECUTION_START";
+    /** 执行结束 */ MonitoringEventType["EXECUTION_END"] = "EXECUTION_END";
+    /** 内存使用变化 */ MonitoringEventType["MEMORY_USAGE"] = "MEMORY_USAGE";
+    /** 性能警告 */ MonitoringEventType["PERFORMANCE_WARNING"] = "PERFORMANCE_WARNING";
+    /** 安全事件 */ MonitoringEventType["SECURITY_EVENT"] = "SECURITY_EVENT";
+    /** 错误事件 */ MonitoringEventType["ERROR_EVENT"] = "ERROR_EVENT";
+    return MonitoringEventType;
+}({});

package/dist/Utils/scrollTo.js

@@ -1,63 +1,55 @@
-// src/Utils/scrollTo.ts
 import raf from "rc-util/lib/raf";
 import { easeInOutCubic } from "./easings";
 import getScroll, { isWindow } from "./getScroll";
-function scrollTo(y, options = {}) {
-  const {
-    container = typeof window !== "undefined" ? window : void 0,
-    callback,
-    duration = 450
-  } = options;
-  if (typeof window === "undefined") {
-    if (typeof callback === "function") {
-      callback();
-    }
-    return;
-  }
-  if (!container) {
-    if (typeof callback === "function") {
-      callback();
-    }
-    return;
-  }
-  const scrollTop = getScroll(container);
-  const startTime = Date.now();
-  const frameFunc = () => {
-    if (typeof window === "undefined") {
-      if (typeof callback === "function") {
-        callback();
-      }
-      return;
+export default function scrollTo(y) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var _options_container = options.container, container = _options_container === void 0 ? typeof window !== 'undefined' ? window : undefined : _options_container, callback = options.callback, _options_duration = options.duration, duration = _options_duration === void 0 ? 450 : _options_duration;
+    // Early return if running in Node.js environment without proper DOM setup
+    if (typeof window === 'undefined') {
+        if (typeof callback === 'function') {
+            callback();
+        }
+        return;
     }
+    // Early return if container is undefined
     if (!container) {
-      if (typeof callback === "function") {
-        callback();
-      }
-      return;
-    }
-    const timestamp = Date.now();
-    const time = timestamp - startTime;
-    const nextScrollTop = easeInOutCubic(
-      time > duration ? duration : time,
-      scrollTop,
-      y,
-      duration
-    );
-    if (isWindow(container)) {
-      container.scrollTo(window.pageXOffset, nextScrollTop);
-    } else if (container instanceof Document || container.constructor.name === "HTMLDocument") {
-      container.documentElement.scrollTop = nextScrollTop;
-    } else {
-      container.scrollTop = nextScrollTop;
-    }
-    if (time < duration) {
-      raf(frameFunc);
-    } else if (typeof callback === "function") {
-      callback();
+        if (typeof callback === 'function') {
+            callback();
+        }
+        return;
     }
-  };
-  raf(frameFunc);
+    var scrollTop = getScroll(container);
+    var startTime = Date.now();
+    var frameFunc = function() {
+        // Check if we're still in a browser environment
+        if (typeof window === 'undefined') {
+            if (typeof callback === 'function') {
+                callback();
+            }
+            return;
+        }
+        // Additional check for container (should not happen due to early return above)
+        if (!container) {
+            if (typeof callback === 'function') {
+                callback();
+            }
+            return;
+        }
+        var timestamp = Date.now();
+        var time = timestamp - startTime;
+        var nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+        if (isWindow(container)) {
+            container.scrollTo(window.pageXOffset, nextScrollTop);
+        } else if (container instanceof Document || container.constructor.name === 'HTMLDocument') {
+            container.documentElement.scrollTop = nextScrollTop;
+        } else {
+            container.scrollTop = nextScrollTop;
+        }
+        if (time < duration) {
+            raf(frameFunc);
+        } else if (typeof callback === 'function') {
+            callback();
+        }
+    };
+    raf(frameFunc);
 }
-export {
-  scrollTo as default
-};

package/dist/Utils/throttleByAnimationFrame.js

@@ -1,23 +1,49 @@
-// src/Utils/throttleByAnimationFrame.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 import raf from "rc-util/lib/raf";
 function throttleByAnimationFrame(fn) {
-  let requestId = null;
-  const later = (args) => () => {
-    requestId = null;
-    fn(...args);
-  };
-  const throttled = (...args) => {
-    if (requestId === null) {
-      requestId = raf(later(args));
-    }
-  };
-  throttled.cancel = () => {
-    raf.cancel(requestId);
-    requestId = null;
-  };
-  return throttled;
+    var requestId = null;
+    var later = function(args) {
+        return function() {
+            requestId = null;
+            fn.apply(void 0, _to_consumable_array(args));
+        };
+    };
+    var throttled = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        if (requestId === null) {
+            requestId = raf(later(args));
+        }
+    };
+    throttled.cancel = function() {
+        raf.cancel(requestId);
+        requestId = null;
+    };
+    return throttled;
 }
-var throttleByAnimationFrame_default = throttleByAnimationFrame;
-export {
-  throttleByAnimationFrame_default as default
-};
+export default throttleByAnimationFrame;

package/dist/WelcomeMessage/index.js

@@ -1,70 +1,118 @@
-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]);
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-// src/WelcomeMessage/index.tsx
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 import { ConfigProvider } from "antd";
 import classnames from "classnames";
 import React, { useContext } from "react";
 import { TextAnimate } from "../Components/TextAnimate";
-import {
-  TypingAnimation
-} from "../Components/TypingAnimation";
+import { TypingAnimation } from "../Components/TypingAnimation";
 import { useStyle } from "./style";
-var WelcomeMessage = ({
-  title,
-  description,
-  classNames,
-  titleAnimateProps,
-  descriptionAnimateProps,
-  style,
-  rootClassName
-}) => {
-  const { getPrefixCls } = useContext(ConfigProvider.ConfigContext);
-  const prefixCls = getPrefixCls("agentic-welcome");
-  const { wrapSSR, hashId } = useStyle(prefixCls);
-  return wrapSSR(
-    /* @__PURE__ */ React.createElement("div", { className: classnames(prefixCls, hashId, rootClassName), style }, title && /* @__PURE__ */ React.createElement(
-      TypingAnimation,
-      __spreadProps(__spreadValues({
+/**
+ * WelcomeMessage 组件 - 欢迎消息组件
+ *
+ * 该组件用于显示聊天开始时的欢迎消息，包含标题和描述信息。
+ * 适用于聊天机器人、客服系统等场景的初始欢迎界面。
+ *
+ * @component
+ * @description 欢迎消息组件，用于显示聊天开始时的欢迎信息
+ * @param {WelcomeMessageProps} props - 组件属性
+ * @param {React.ReactNode} [props.title] - 欢迎标题
+ * @param {string} [props.description] - 欢迎描述
+ * @param {Object} [props.classNames] - 自定义样式类名
+ * @param {string} [props.classNames.title] - 标题样式类名
+ * @param {string} [props.classNames.description] - 描述样式类名
+ * @param {WelcomeMessageTitleAnimateProps} [props.titleAnimateProps] - 标题动画属性
+ * @param {WelcomeMessageDescriptionAnimateProps} [props.descriptionAnimateProps] - 描述动画属性
+ * @param {React.CSSProperties} [props.style] - 自定义样式
+ * @param {string} [props.rootClassName] - 根节点样式类名
+ *
+ * @example
+ * ```tsx
+ * <WelcomeMessage
+ *   title="欢迎使用 AI 助手"
+ *   description="我可以帮助您解答问题、提供建议和完成任务"
+ *   classNames={{
+ *     title: 'custom-title',
+ *     description: 'custom-description'
+ *   }}
+ * />
+ * ```
+ *
+ * @returns {React.ReactElement} 渲染的欢迎消息组件
+ *
+ * @remarks
+ * - 支持自定义标题和描述
+ * - 提供灵活的样式配置
+ * - 支持 React.ReactNode 类型内容
+ * - 集成 Ant Design 主题系统
+ * - 响应式布局适配
+ */ export var WelcomeMessage = function(param) {
+    var title = param.title, description = param.description, classNames = param.classNames, titleAnimateProps = param.titleAnimateProps, descriptionAnimateProps = param.descriptionAnimateProps, style = param.style, rootClassName = param.rootClassName;
+    var getPrefixCls = useContext(ConfigProvider.ConfigContext).getPrefixCls;
+    var prefixCls = getPrefixCls('agentic-welcome');
+    var _useStyle = useStyle(prefixCls), wrapSSR = _useStyle.wrapSSR, hashId = _useStyle.hashId;
+    return wrapSSR(/*#__PURE__*/ React.createElement("div", {
+        className: classnames(prefixCls, hashId, rootClassName),
+        style: style
+    }, title && /*#__PURE__*/ React.createElement(TypingAnimation, _object_spread_props(_object_spread({
         as: "div"
-      }, titleAnimateProps), {
-        className: classnames(`${prefixCls}-title`, classNames == null ? void 0 : classNames.title)
-      }),
-      title
-    ), description && /* @__PURE__ */ React.createElement(
-      TextAnimate,
-      __spreadProps(__spreadValues({
+    }, titleAnimateProps), {
+        className: classnames("".concat(prefixCls, "-title"), classNames === null || classNames === void 0 ? void 0 : classNames.title)
+    }), title), description && /*#__PURE__*/ React.createElement(TextAnimate, _object_spread_props(_object_spread({
         as: "div",
         animation: "blurInUp",
         by: "character",
         once: true
-      }, descriptionAnimateProps), {
-        className: classnames(
-          `${prefixCls}-description`,
-          classNames == null ? void 0 : classNames.description
-        )
-      }),
-      description
-    ))
-  );
-};
-export {
-  WelcomeMessage
+    }, descriptionAnimateProps), {
+        className: classnames("".concat(prefixCls, "-description"), classNames === null || classNames === void 0 ? void 0 : classNames.description)
+    }), description)));
 };