@ant-design/agentic-ui 2.0.10 → 2.0.13

package/dist/Plugins/chart/utils.js

@@ -0,0 +1,98 @@
+// src/Plugins/chart/utils.ts
+var intl = new Intl.NumberFormat("en-US", {
+  style: "decimal"
+});
+var stringFormatNumber = (value) => {
+  if (!value)
+    return value;
+  try {
+    if (typeof value === "string")
+      return value;
+    if (typeof value === "number") {
+      return intl.format(Number(value));
+    }
+    return value;
+  } catch (error) {
+    return value;
+  }
+};
+function debounce(func, delay) {
+  let timer = null;
+  const fn = function() {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func.apply(this, arguments);
+    }, delay);
+  };
+  fn.flush = function() {
+    clearTimeout(timer);
+    func.apply(this, arguments);
+  };
+  fn.cancel = function() {
+    clearTimeout(timer);
+  };
+  return fn;
+}
+var normalizeXValue = (value) => {
+  if (typeof value === "number")
+    return value;
+  const s = String(value).trim();
+  if (s === "")
+    return value;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : value;
+};
+var compareXValues = (a, b) => {
+  const normalizedA = normalizeXValue(a);
+  const normalizedB = normalizeXValue(b);
+  if (typeof normalizedA === "number" && typeof normalizedB === "number") {
+    return normalizedA - normalizedB;
+  }
+  if (typeof normalizedA === "number" && typeof normalizedB === "string") {
+    return -1;
+  }
+  if (typeof normalizedA === "string" && typeof normalizedB === "number") {
+    return 1;
+  }
+  return String(normalizedA).localeCompare(String(normalizedB));
+};
+var isXValueEqual = (a, b) => {
+  const normalizedA = normalizeXValue(a);
+  const normalizedB = normalizeXValue(b);
+  if (typeof normalizedA === "number" && typeof normalizedB === "number") {
+    return normalizedA === normalizedB;
+  }
+  return String(normalizedA) === String(normalizedB);
+};
+var extractAndSortXValues = (data) => {
+  const normalizedValues = data.map((item) => normalizeXValue(item.x));
+  const uniqueValues = [...new Set(normalizedValues)];
+  return uniqueValues.sort(compareXValues);
+};
+var findDataPointByXValue = (data, xValue, type) => {
+  if (!type)
+    return data.find((item) => isXValueEqual(item.x, xValue));
+  return data.find(
+    (item) => item.type === type && isXValueEqual(item.x, xValue)
+  );
+};
+var toNumber = (val, fallback) => {
+  if (typeof val === "number" && !Number.isNaN(val))
+    return val;
+  const n = Number(val);
+  return Number.isFinite(n) ? n : fallback;
+};
+var isNotEmpty = (val) => {
+  return val !== null && val !== void 0;
+};
+export {
+  compareXValues,
+  debounce,
+  extractAndSortXValues,
+  findDataPointByXValue,
+  isNotEmpty,
+  isXValueEqual,
+  normalizeXValue,
+  stringFormatNumber,
+  toNumber
+};

package/dist/Plugins/code/CodeUI/Katex/Katex.js

@@ -0,0 +1,75 @@
+// src/Plugins/code/CodeUI/Katex/Katex.tsx
+import classNames from "classnames";
+import katex from "katex";
+import React, { useEffect, useRef } from "react";
+import { useGetSetState } from "react-use";
+import "./katex.min.css";
+var Katex = (props) => {
+  const [state, setState] = useGetSetState({
+    code: "",
+    error: ""
+  });
+  const divRef = useRef(null);
+  const timer = useRef(0);
+  const safeEl = props.el || { value: "", type: "code", language: "katex" };
+  useEffect(() => {
+    const code = safeEl.value || "";
+    clearTimeout(timer.current);
+    timer.current = window.setTimeout(
+      () => {
+        setState({
+          code
+        });
+        if (state().code) {
+          try {
+            if (divRef.current) {
+              katex.render(state().code, divRef.current, {
+                strict: false,
+                output: "htmlAndMathml",
+                throwOnError: false,
+                displayMode: true,
+                macros: {
+                  "\\f": "#1f(#2)"
+                }
+              });
+            }
+          } catch (e) {
+          }
+        } else {
+          setState({ error: "" });
+        }
+      },
+      !state().code ? 0 : 300
+    );
+    return () => window.clearTimeout(timer.current);
+  }, [safeEl]);
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        marginBottom: "0.75em",
+        cursor: "default",
+        userSelect: "none",
+        textAlign: "center",
+        backgroundColor: "rgba(107, 114, 128, 0.05)",
+        paddingTop: "1em",
+        paddingBottom: "1em",
+        borderRadius: "0.25em"
+      },
+      contentEditable: false
+    },
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        ref: divRef,
+        className: classNames("katex-container", {
+          hidden: !state().code.trim()
+        })
+      }
+    ),
+    !state().code.trim() && /* @__PURE__ */ React.createElement("div", { style: { textAlign: "center", color: "#6B7280" } }, "Formula")
+  );
+};
+export {
+  Katex
+};

package/dist/Plugins/code/components/AceEditor.js

@@ -0,0 +1,257 @@
+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;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/Plugins/code/components/AceEditor.tsx
+import ace from "ace-builds";
+import "ace-builds/src-noconflict/theme-chaos";
+import "ace-builds/src-noconflict/theme-github";
+import isHotkey from "is-hotkey";
+import { useCallback, useEffect, useRef } from "react";
+import { Editor, Path, Transforms } from "slate";
+import { ReactEditor } from "slate-react";
+import partialParse from "../../../MarkdownEditor/editor/parser/json-parse";
+import { useEditorStore } from "../../../MarkdownEditor/editor/store";
+import { aceLangs, modeMap } from "../../../MarkdownEditor/editor/utils/ace";
+import { EditorUtils } from "../../../MarkdownEditor/editor/utils/editorUtils";
+function AceEditor(_a) {
+  var _b = _a, {
+    element,
+    onUpdate,
+    onShowBorderChange,
+    onHideChange,
+    path,
+    isSelected = false,
+    onSelectionChange
+  } = _b, props = __objRest(_b, [
+    "element",
+    "onUpdate",
+    "onShowBorderChange",
+    "onHideChange",
+    "path",
+    "isSelected",
+    "onSelectionChange"
+  ]);
+  var _a2;
+  const { store, editorProps, readonly } = useEditorStore();
+  const codeRef = useRef(element.value || "");
+  const pathRef = useRef(path);
+  const posRef = useRef({ row: 0, column: 0 });
+  const pasted = useRef(false);
+  const debounceTimer = useRef(0);
+  const editorRef = useRef();
+  const dom = useRef(null);
+  useEffect(() => {
+    pathRef.current = path;
+  }, [path]);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (isHotkey("backspace", e)) {
+        if (!codeRef.current) {
+          const currentPath = ReactEditor.findPath(store.editor, element);
+          Transforms.delete(store.editor, { at: currentPath });
+          Transforms.insertNodes(
+            store.editor,
+            { type: "paragraph", children: [{ text: "" }] },
+            { at: currentPath }
+          );
+          Transforms.select(
+            store.editor,
+            Editor.start(store.editor, currentPath)
+          );
+          ReactEditor.focus(store.editor);
+        }
+      }
+      if (isHotkey("mod+enter", e) && pathRef.current) {
+        EditorUtils.focus(store.editor);
+        Transforms.insertNodes(
+          store.editor,
+          { type: "paragraph", children: [{ text: "" }] },
+          { at: Path.next(pathRef.current), select: true }
+        );
+        e.stopPropagation();
+        return;
+      }
+      const newEvent = new KeyboardEvent(e.type, e);
+      window.dispatchEvent(newEvent);
+    },
+    [element, store.editor]
+  );
+  const setupEditorEvents = useCallback(
+    (codeEditor) => {
+      codeEditor.commands.addCommand({
+        name: "disableFind",
+        bindKey: { win: "Ctrl-F", mac: "Command-F" },
+        exec: () => {
+        }
+      });
+      const textarea = dom.current.querySelector("textarea");
+      codeEditor.on("focus", () => {
+        onShowBorderChange(false);
+        onHideChange(false);
+      });
+      codeEditor.on("blur", () => {
+        codeEditor.selection.clearSelection();
+      });
+      codeEditor.selection.on("changeCursor", () => {
+        setTimeout(() => {
+          const pos = codeEditor.getCursorPosition();
+          posRef.current = { row: pos.row, column: pos.column };
+        });
+      });
+      codeEditor.on("paste", (e) => {
+        if (pasted.current) {
+          e.text = "";
+        } else {
+          pasted.current = true;
+          setTimeout(() => {
+            pasted.current = false;
+          }, 60);
+        }
+      });
+      codeEditor.on("focus", () => {
+        onSelectionChange == null ? void 0 : onSelectionChange(true);
+      });
+      codeEditor.on("blur", () => {
+        setTimeout(() => {
+          onSelectionChange == null ? void 0 : onSelectionChange(false);
+        }, 160);
+      });
+      textarea == null ? void 0 : textarea.addEventListener("keydown", handleKeyDown);
+      codeEditor.on("change", () => {
+        if (readonly)
+          return;
+        clearTimeout(debounceTimer.current);
+        debounceTimer.current = window.setTimeout(() => {
+          onUpdate({ value: codeEditor.getValue() });
+          codeRef.current = codeEditor.getValue();
+        }, 100);
+      });
+    },
+    [onUpdate, onShowBorderChange, onHideChange, readonly, handleKeyDown]
+  );
+  useEffect(() => {
+    var _a3;
+    if (false)
+      return;
+    if (!dom.current)
+      return;
+    let value = element.value || "";
+    if (element.language === "json") {
+      try {
+        value = JSON.stringify(partialParse(value), null, 2);
+      } catch (e) {
+      }
+    }
+    const codeEditor = ace.edit(dom.current, __spreadValues({
+      useWorker: false,
+      value,
+      fontSize: 12,
+      animatedScroll: true,
+      maxLines: Infinity,
+      wrap: true,
+      tabSize: 4,
+      readOnly: readonly,
+      showPrintMargin: false,
+      showLineNumbers: true,
+      showGutter: true
+    }, editorProps.codeProps || {}));
+    editorRef.current = codeEditor;
+    const theme = ((_a3 = editorProps.codeProps) == null ? void 0 : _a3.theme) || props.theme || "github";
+    codeEditor.setTheme(`ace/theme/${theme}`);
+    setTimeout(() => {
+      let lang = element.language;
+      if (modeMap.has(lang)) {
+        lang = modeMap.get(lang);
+      }
+      if (aceLangs.has(lang)) {
+        codeEditor.session.setMode(`ace/mode/${lang}`);
+      }
+    }, 16);
+    if (readonly)
+      return;
+    setupEditorEvents(codeEditor);
+    return () => {
+      codeEditor.destroy();
+    };
+  }, []);
+  useEffect(() => {
+    var _a3, _b2;
+    let value = element.value || "";
+    if (element.language === "json") {
+      try {
+        value = JSON.stringify(partialParse(value), null, 2);
+      } catch (e) {
+      }
+    }
+    if (value !== codeRef.current) {
+      if (element)
+        (_a3 = editorRef.current) == null ? void 0 : _a3.setValue(value || "plain text");
+      (_b2 = editorRef.current) == null ? void 0 : _b2.clearSelection();
+    }
+  }, [element.value]);
+  useEffect(() => {
+    var _a3;
+    if (!editorRef.current)
+      return;
+    const theme = ((_a3 = editorProps.codeProps) == null ? void 0 : _a3.theme) || props.theme || "github";
+    editorRef.current.setTheme(`ace/theme/${theme}`);
+  }, [(_a2 = editorProps.codeProps) == null ? void 0 : _a2.theme, props.theme]);
+  const setLanguage = useCallback(
+    (changeLang) => {
+      var _a3, _b2, _c;
+      let lang = changeLang.toLowerCase();
+      if (((_a3 = element.language) == null ? void 0 : _a3.toLowerCase()) === lang)
+        return;
+      onUpdate({ language: lang });
+      if (modeMap.has(lang)) {
+        lang = modeMap.get(lang);
+      }
+      if (aceLangs.has(lang)) {
+        (_b2 = editorRef.current) == null ? void 0 : _b2.session.setMode(`ace/mode/${lang}`);
+      } else {
+        (_c = editorRef.current) == null ? void 0 : _c.session.setMode(`ace/mode/text`);
+      }
+    },
+    [element, onUpdate]
+  );
+  return {
+    dom,
+    editorRef,
+    setLanguage,
+    focusEditor: () => {
+      var _a3;
+      return (_a3 = editorRef.current) == null ? void 0 : _a3.focus();
+    },
+    isSelected,
+    onSelectionChange
+  };
+}
+export {
+  AceEditor
+};

package/dist/Plugins/code/components/AceEditorContainer.js

@@ -0,0 +1,33 @@
+// src/Plugins/code/components/AceEditorContainer.tsx
+import React from "react";
+function AceEditorContainer({
+  dom,
+  element,
+  children
+}) {
+  var _a;
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      "data-testid": "ace-editor-container",
+      ref: dom,
+      style: { height: 200, lineHeight: 1.6 }
+    }
+  ), /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      "data-testid": "code-content-copy",
+      style: {
+        height: "0.5px",
+        overflow: "hidden",
+        opacity: 0,
+        pointerEvents: "none"
+      }
+    },
+    (_a = element == null ? void 0 : element.value) == null ? void 0 : _a.replaceAll("\n", " "),
+    children
+  ));
+}
+export {
+  AceEditorContainer
+};

package/dist/Plugins/code/components/CodeContainer.js

@@ -0,0 +1,63 @@
+// src/Plugins/code/components/CodeContainer.tsx
+import classNames from "classnames";
+import React, { useRef } from "react";
+function CodeContainer({
+  element,
+  showBorder,
+  hide,
+  onEditorClick,
+  children,
+  theme
+}) {
+  const containerRef = useRef(null);
+  const safeElement = element || {
+    language: void 0,
+    frontmatter: false
+  };
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      contentEditable: false,
+      className: "ace-el drag-el",
+      "data-be": "code",
+      "data-testid": "code-container",
+      ref: containerRef,
+      tabIndex: -1,
+      onBlur: (e) => e.stopPropagation(),
+      onClick: (e) => e.stopPropagation(),
+      "data-lang": safeElement.language
+    },
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        "data-testid": "code-editor-container",
+        onClick: (e) => {
+          e.stopPropagation();
+          onEditorClick();
+        },
+        style: {
+          padding: hide ? 1 : 1,
+          marginBottom: hide ? 0 : void 0,
+          boxShadow: "var(--shadow-control-base)",
+          borderRadius: "var(--radius-card-base)",
+          backgroundColor: showBorder ? "rgba(59, 130, 246, 0.1)" : hide ? "transparent" : theme === "chaos" ? "var(--color-gray-text-default)" : "rgb(252, 252, 252)",
+          color: theme === "chaos" ? "#FFFFFF" : "var(--color-gray-text-default)",
+          height: hide ? 0 : "auto",
+          opacity: hide ? 0 : 1
+        },
+        className: classNames(
+          "ace-container",
+          "code-editor-container",
+          "drag-el",
+          {
+            frontmatter: safeElement.frontmatter
+          }
+        )
+      },
+      children
+    )
+  );
+}
+export {
+  CodeContainer
+};

package/dist/Plugins/code/components/CodeRenderer.js

@@ -0,0 +1,163 @@
+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/Plugins/code/components/CodeRenderer.tsx
+import { ConfigProvider, theme as antdTheme } from "antd";
+import React, { useMemo, useState } from "react";
+import { MarkdownEditor } from "../../../MarkdownEditor";
+import { useEditorStore } from "../../../MarkdownEditor/editor/store";
+import {
+  useCodeEditorState,
+  useRenderConditions,
+  useToolbarConfig
+} from "../hooks";
+import {
+  AceEditor,
+  AceEditorContainer,
+  CodeContainer,
+  CodeToolbar,
+  HtmlPreview,
+  ThinkBlock
+} from "./index";
+function CodeRenderer(props) {
+  var _a;
+  const { editorProps, readonly } = useEditorStore();
+  const {
+    state,
+    update,
+    path,
+    handleCloseClick,
+    handleHtmlPreviewClose,
+    handleShowBorderChange,
+    handleHideChange
+  } = useCodeEditorState(props.element);
+  const [theme, setTheme] = useState("github");
+  const [isExpanded, setIsExpanded] = useState(true);
+  const [isSelected, setIsSelected] = React.useState(false);
+  const [viewMode, setViewMode] = useState("code");
+  const { dom, setLanguage, focusEditor } = AceEditor({
+    element: props.element,
+    theme,
+    onUpdate: update,
+    onShowBorderChange: handleShowBorderChange,
+    onHideChange: handleHideChange,
+    path,
+    isSelected,
+    onSelectionChange: setIsSelected
+  });
+  const {
+    shouldHideConfigHtml,
+    shouldRenderAsThinkBlock,
+    shouldRenderAsCodeEditor
+  } = useRenderConditions(props.element, readonly);
+  const handleViewModeToggle = () => {
+    setViewMode((prev) => prev === "preview" ? "code" : "preview");
+  };
+  const { toolbarProps } = useToolbarConfig({
+    element: props.element,
+    readonly,
+    onCloseClick: handleCloseClick,
+    setLanguage,
+    onSelectionChange: setIsSelected,
+    onViewModeToggle: handleViewModeToggle,
+    viewMode
+  });
+  return useMemo(() => {
+    var _a2, _b, _c;
+    if (shouldHideConfigHtml) {
+      return null;
+    }
+    if (shouldRenderAsThinkBlock) {
+      return /* @__PURE__ */ React.createElement(ThinkBlock, { element: props.element });
+    }
+    if (shouldRenderAsCodeEditor) {
+      return /* @__PURE__ */ React.createElement(
+        ConfigProvider,
+        {
+          theme: {
+            algorithm: theme === "chaos" ? antdTheme.darkAlgorithm : antdTheme.defaultAlgorithm
+          }
+        },
+        /* @__PURE__ */ React.createElement("div", __spreadValues({}, props.attributes), /* @__PURE__ */ React.createElement(
+          CodeContainer,
+          {
+            theme,
+            element: props.element,
+            showBorder: state.showBorder,
+            hide: state.hide,
+            onEditorClick: focusEditor
+          },
+          !props.element.frontmatter && !((_a2 = editorProps.codeProps) == null ? void 0 : _a2.hideToolBar) && /* @__PURE__ */ React.createElement(
+            CodeToolbar,
+            __spreadValues({
+              theme,
+              setTheme,
+              isExpanded,
+              onExpandToggle: () => setIsExpanded(!isExpanded)
+            }, toolbarProps)
+          ),
+          /* @__PURE__ */ React.createElement(
+            "div",
+            {
+              className: "code-editor-content",
+              style: {
+                borderBottomLeftRadius: "inherit",
+                borderBottomRightRadius: "inherit",
+                display: isExpanded ? "block" : "none"
+              }
+            },
+            viewMode === "preview" && props.element.language === "html" && /* @__PURE__ */ React.createElement(HtmlPreview, { htmlStr: (_b = props.element) == null ? void 0 : _b.value }),
+            viewMode === "preview" && props.element.language && props.element.language === "markdown" && /* @__PURE__ */ React.createElement(MarkdownEditor, { initValue: (_c = props.element) == null ? void 0 : _c.value }),
+            /* @__PURE__ */ React.createElement(
+              "div",
+              {
+                style: {
+                  height: "100%",
+                  width: "100%",
+                  borderRadius: "inherit",
+                  padding: "12px 0",
+                  display: viewMode === "code" ? "block" : "none"
+                }
+              },
+              /* @__PURE__ */ React.createElement(AceEditorContainer, { dom, element: props.element }, props.children)
+            )
+          )
+        ))
+      );
+    }
+    return null;
+  }, [
+    shouldHideConfigHtml,
+    shouldRenderAsThinkBlock,
+    shouldRenderAsCodeEditor,
+    props.element,
+    props.attributes,
+    props.children,
+    state.showBorder,
+    state.hide,
+    state.htmlStr,
+    isSelected,
+    (_a = editorProps.codeProps) == null ? void 0 : _a.hideToolBar,
+    toolbarProps,
+    handleHtmlPreviewClose,
+    viewMode,
+    handleViewModeToggle
+  ]);
+}
+export {
+  CodeRenderer
+};