@ant-design/agentic-ui 2.0.0

package/dist/MarkdownEditor/editor/utils/markdownToHtml.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 将 Markdown 内容转换为 HTML（异步版本）
+ *
+ * 使用 unified 处理器链来处理 Markdown 到 HTML 的转换，支持：
+ * - GitHub 风味 Markdown (GFM)
+ * - 数学公式 (KaTeX)
+ * - 前置元数据 (Frontmatter)
+ * - 特殊字符修复
+ * - 原始 HTML 标签
+ *
+ * @param markdown - 要转换的 Markdown 字符串
+ * @returns Promise<string> - 从 Markdown 生成的 HTML 字符串
+ *
+ * @example
+ * ```typescript
+ * const html = await markdownToHtml('# 标题\n\n这是**粗体**文本');
+ * console.log(html); // '<h1>标题</h1><p>这是<strong>粗体</strong>文本</p>'
+ * ```
+ *
+ * @throws {Error} 当转换过程中发生错误时返回空字符串
+ */
+export declare const markdownToHtml: (markdown: string) => Promise<string>;
+/**
+ * 将 Markdown 内容转换为 HTML（同步版本）
+ *
+ * 同步版本的 markdownToHtml，使用相同的处理器链但以同步方式执行。
+ * 适用于不需要异步处理的场景，但可能会阻塞主线程。
+ *
+ * @param markdown - 要转换的 Markdown 字符串
+ * @returns string - 从 Markdown 生成的 HTML 字符串
+ *
+ * @example
+ * ```typescript
+ * const html = markdownToHtmlSync('## 副标题\n\n- 列表项1\n- 列表项2');
+ * console.log(html); // '<h2>副标题</h2><ul><li>列表项1</li><li>列表项2</li></ul>'
+ * ```
+ *
+ * @throws {Error} 当转换过程中发生错误时返回空字符串
+ *
+ * @remarks
+ * - 建议在可能的情况下使用异步版本 `markdownToHtml`
+ * - 同步版本可能影响用户界面响应性
+ */
+export declare const markdownToHtmlSync: (markdown: string) => string;

package/dist/MarkdownEditor/editor/utils/markdownToHtml.js

@@ -0,0 +1,61 @@
+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/MarkdownEditor/editor/utils/markdownToHtml.ts
+import rehypeKatex from "rehype-katex";
+import rehypeRaw from "rehype-raw";
+import rehypeStringify from "rehype-stringify";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { fixStrongWithSpecialChars } from "../parser/remarkParse";
+var markdownToHtml = (markdown) => __async(void 0, null, function* () {
+  try {
+    const htmlContent = yield unified().use(remarkParse).use(remarkGfm).use(fixStrongWithSpecialChars).use(remarkMath, {
+      singleDollarTextMath: false
+      // 禁用单美元符号数学公式
+    }).use(remarkFrontmatter, ["yaml"]).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(rehypeKatex).use(rehypeStringify).process(markdown);
+    return String(htmlContent);
+  } catch (error) {
+    console.error("Error converting markdown to HTML:", error);
+    return "";
+  }
+});
+var markdownToHtmlSync = (markdown) => {
+  try {
+    const processor = unified().use(remarkParse).use(remarkGfm).use(fixStrongWithSpecialChars).use(remarkMath, {
+      singleDollarTextMath: false
+      // 禁用单美元符号数学公式
+    }).use(remarkFrontmatter, ["yaml"]).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(rehypeKatex).use(rehypeStringify);
+    const file = processor.processSync(markdown);
+    return String(file);
+  } catch (error) {
+    console.error("Error converting markdown to HTML:", error);
+    return "";
+  }
+};
+export {
+  markdownToHtml,
+  markdownToHtmlSync
+};

package/dist/MarkdownEditor/editor/utils/media.d.ts

@@ -0,0 +1,4 @@
+import { IEditor } from '../../BaseMarkdownEditor';
+import { EditorStore } from '../store';
+export declare const getRemoteMediaType: (url: string) => Promise<string | null>;
+export declare const convertRemoteImages: (node: IEditor, store: EditorStore) => Promise<void>;

package/dist/MarkdownEditor/editor/utils/media.js

@@ -0,0 +1,106 @@
+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/MarkdownEditor/editor/utils/media.ts
+import { Transforms } from "slate";
+import { ReactEditor } from "slate-react";
+import { getMediaType } from "./dom";
+var getRemoteMediaType = (url) => __async(void 0, null, function* () {
+  if (!url)
+    return "other";
+  if (url.startsWith("data:")) {
+    const m = url.match(/data:image\/(\w+);base64,(.*)/);
+    if (m)
+      return m[1];
+    return "other";
+  }
+  if (typeof url !== "string")
+    return "other";
+  try {
+    const type = getMediaType(url);
+    if (type !== "other")
+      return type;
+    let contentType = "";
+    const controller = new AbortController();
+    const res = yield fetch(url, {
+      method: "HEAD",
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      throw new Error();
+    }
+    setTimeout(() => {
+      controller.abort();
+    }, 1e3);
+    contentType = res.headers.get("content-type") || "";
+    return contentType.split("/")[0];
+  } catch (e) {
+    return null;
+  }
+});
+var convertRemoteImages = (node, store) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d;
+  const schema = ((_a = store == null ? void 0 : store.editor) == null ? void 0 : _a.children) || [];
+  if (schema) {
+    const stack = schema.slice();
+    while (stack.length) {
+      const item = stack.pop();
+      if (item.type === "media") {
+        if ((_b = item == null ? void 0 : item.url) == null ? void 0 : _b.startsWith("http")) {
+          const ext = item == null ? void 0 : item.url.match(/[\w_-]+\.(png|webp|jpg|jpeg|gif|svg)/i);
+          if (ext) {
+            try {
+              Transforms.setNodes(
+                store == null ? void 0 : store.editor,
+                {
+                  url: item == null ? void 0 : item.url
+                },
+                { at: ReactEditor.findPath(store == null ? void 0 : store.editor, item) }
+              );
+            } catch (e) {
+              console.error(e);
+            }
+          }
+        } else if ((_c = item == null ? void 0 : item.url) == null ? void 0 : _c.startsWith("data:")) {
+          const m = item == null ? void 0 : item.url.match(/data:image\/(\w+);base64,(.*)/);
+          if (m) {
+            try {
+              Transforms.setNodes(
+                store == null ? void 0 : store.editor,
+                {
+                  url: item == null ? void 0 : item.url
+                },
+                { at: ReactEditor.findPath(store == null ? void 0 : store.editor, item) }
+              );
+            } catch (e) {
+            }
+          }
+        }
+      } else if ((_d = item == null ? void 0 : item.children) == null ? void 0 : _d.length) {
+        stack.push(...item == null ? void 0 : item.children);
+      }
+    }
+  }
+});
+export {
+  convertRemoteImages,
+  getRemoteMediaType
+};

package/dist/MarkdownEditor/editor/utils/path.d.ts

@@ -0,0 +1,9 @@
+export declare const isLink: (url?: string) => boolean;
+export declare const parsePath: (path: string) => {
+    path: string;
+    hash: string;
+} | {
+    path: string;
+    hash: null;
+};
+export declare const toUnixPath: (path: string) => string;

package/dist/MarkdownEditor/editor/utils/path.js

@@ -0,0 +1,19 @@
+// src/MarkdownEditor/editor/utils/path.ts
+import slash from "slash2";
+var isLink = (url = "") => /^[a-zA-Z]+:(\/\/)?/i.test(url);
+var parsePath = (path) => {
+  const m = path.match(/#([^\n]*)/);
+  if (m) {
+    const hashPart = m[0];
+    const hashValue = m[1] || "";
+    const pathWithoutHash = path.replace(hashPart, "").split("\n")[0];
+    return { path: pathWithoutHash, hash: hashValue };
+  }
+  return { path, hash: null };
+};
+var toUnixPath = (path) => slash(path);
+export {
+  isLink,
+  parsePath,
+  toUnixPath
+};

package/dist/MarkdownEditor/editor/utils/performanceMonitor.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 性能监控工具
+ * 用于监控粘贴操作的性能表现
+ */
+interface PerformanceMetrics {
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    contentSize: number;
+    contentType: 'text' | 'html' | 'files' | 'mixed';
+    operationType: 'parse' | 'upload' | 'insert' | 'total';
+}
+declare class PerformanceMonitor {
+    private metrics;
+    private isEnabled;
+    /**
+     * 开始监控
+     */
+    startMonitoring(operationId: string, contentType: PerformanceMetrics['contentType'], contentSize: number): void;
+    /**
+     * 记录子操作开始
+     */
+    startSubOperation(operationId: string, subOperation: PerformanceMetrics['operationType']): void;
+    /**
+     * 记录子操作结束
+     */
+    endSubOperation(operationId: string, subOperation: PerformanceMetrics['operationType']): void;
+    /**
+     * 结束监控
+     */
+    endMonitoring(operationId: string): void;
+    /**
+     * 获取性能评级
+     */
+    private getPerformanceRating;
+    /**
+     * 格式化文件大小
+     */
+    private formatSize;
+    /**
+     * 获取操作名称
+     */
+    private getOperationName;
+    /**
+     * 启用/禁用监控
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 获取性能报告
+     */
+    getReport(): {
+        totalOperations: number;
+        averageDuration: number;
+    };
+}
+export declare const performanceMonitor: PerformanceMonitor;
+/**
+ * 性能监控装饰器
+ */
+export declare const withPerformanceMonitoring: <T extends any[], R>(operationType: PerformanceMetrics['operationType'], fn: (...args: T) => Promise<R> | R) => (...args: T) => Promise<R>;
+/**
+ * 生成操作ID
+ */
+export declare const generateOperationId: () => string;
+export {};

package/dist/MarkdownEditor/editor/utils/performanceMonitor.js

@@ -0,0 +1,182 @@
+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/MarkdownEditor/editor/utils/performanceMonitor.ts
+var PerformanceMonitor = class {
+  constructor() {
+    this.metrics = /* @__PURE__ */ new Map();
+    this.isEnabled = true;
+  }
+  /**
+   * 开始监控
+   */
+  startMonitoring(operationId, contentType, contentSize) {
+    if (!this.isEnabled)
+      return;
+    this.metrics.set(operationId, {
+      startTime: performance.now(),
+      contentSize,
+      contentType,
+      operationType: "total"
+    });
+    console.log(`🚀 开始粘贴操作 [${operationId}]:`, {
+      contentType,
+      contentSize: this.formatSize(contentSize)
+    });
+  }
+  /**
+   * 记录子操作开始
+   */
+  startSubOperation(operationId, subOperation) {
+    if (!this.isEnabled)
+      return;
+    const metric = this.metrics.get(operationId);
+    if (metric) {
+      this.metrics.set(`${operationId}-${subOperation}`, {
+        startTime: performance.now(),
+        contentSize: metric.contentSize,
+        contentType: metric.contentType,
+        operationType: subOperation
+      });
+    }
+  }
+  /**
+   * 记录子操作结束
+   */
+  endSubOperation(operationId, subOperation) {
+    if (!this.isEnabled)
+      return;
+    const subMetricId = `${operationId}-${subOperation}`;
+    const metric = this.metrics.get(subMetricId);
+    if (metric) {
+      metric.endTime = performance.now();
+      metric.duration = metric.endTime - metric.startTime;
+      console.log(
+        `✅ ${this.getOperationName(subOperation)} 完成 [${operationId}]:`,
+        {
+          duration: `${metric.duration.toFixed(2)}ms`,
+          contentSize: this.formatSize(metric.contentSize)
+        }
+      );
+    }
+  }
+  /**
+   * 结束监控
+   */
+  endMonitoring(operationId) {
+    if (!this.isEnabled)
+      return;
+    const metric = this.metrics.get(operationId);
+    if (metric) {
+      metric.endTime = performance.now();
+      metric.duration = metric.endTime - metric.startTime;
+      console.log(`🎉 粘贴操作完成 [${operationId}]:`, {
+        totalDuration: `${metric.duration.toFixed(2)}ms`,
+        contentType: metric.contentType,
+        contentSize: this.formatSize(metric.contentSize),
+        performance: this.getPerformanceRating(
+          metric.duration,
+          metric.contentSize
+        )
+      });
+      this.metrics.delete(operationId);
+    }
+  }
+  /**
+   * 获取性能评级
+   */
+  getPerformanceRating(duration, contentSize) {
+    const sizeInKB = contentSize / 1024;
+    const durationPerKB = duration / sizeInKB;
+    if (durationPerKB < 10)
+      return "🚀 优秀";
+    if (durationPerKB < 50)
+      return "✅ 良好";
+    if (durationPerKB < 100)
+      return "⚠️ 一般";
+    return "🐌 较慢";
+  }
+  /**
+   * 格式化文件大小
+   */
+  formatSize(bytes) {
+    if (bytes < 1024)
+      return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  /**
+   * 获取操作名称
+   */
+  getOperationName(operationType) {
+    const names = {
+      parse: "内容解析",
+      upload: "文件上传",
+      insert: "内容插入",
+      total: "总操作"
+    };
+    return names[operationType];
+  }
+  /**
+   * 启用/禁用监控
+   */
+  setEnabled(enabled) {
+    this.isEnabled = enabled;
+  }
+  /**
+   * 获取性能报告
+   */
+  getReport() {
+    const operations = Array.from(this.metrics.values()).filter(
+      (m) => m.duration
+    );
+    const totalOperations = operations.length;
+    const averageDuration = operations.reduce((sum, m) => sum + (m.duration || 0), 0) / totalOperations;
+    return {
+      totalOperations,
+      averageDuration
+    };
+  }
+};
+var performanceMonitor = new PerformanceMonitor();
+var withPerformanceMonitoring = (operationType, fn) => {
+  return (...args) => __async(void 0, null, function* () {
+    const operationId = `${operationType}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    performanceMonitor.startSubOperation(operationId, operationType);
+    try {
+      const result = yield fn(...args);
+      performanceMonitor.endSubOperation(operationId, operationType);
+      return result;
+    } catch (error) {
+      console.error(`❌ ${operationType} 操作失败:`, error);
+      throw error;
+    }
+  });
+};
+var generateOperationId = () => {
+  return `paste-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+};
+export {
+  generateOperationId,
+  performanceMonitor,
+  withPerformanceMonitoring
+};

package/dist/MarkdownEditor/editor/utils/useLocalState.d.ts

@@ -0,0 +1,8 @@
+type GetFields<T, K = {
+    [P in keyof T]: T[P] extends Function ? never : P;
+}> = K[keyof K];
+type SetState<T extends Record<string, any>, F extends GetFields<T>> = (data: {
+    [P in F]?: T[P];
+} | ((state: T) => void)) => void;
+export declare const useLocalState: <T extends Record<string, any>>(data: (() => T) | T) => [T, SetState<T, GetFields<T>>];
+export {};

package/dist/MarkdownEditor/editor/utils/useLocalState.js

@@ -0,0 +1,40 @@
+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/MarkdownEditor/editor/utils/useLocalState.ts
+import { useCallback, useRef, useState } from "react";
+var useLocalState = (data) => {
+  const initialData = data instanceof Function ? data() : data;
+  const [state, setReactState] = useState(initialData);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const setState = useCallback((update) => {
+    if (update instanceof Function) {
+      setReactState((prevState) => {
+        const newState = __spreadValues({}, prevState);
+        update(newState);
+        return newState;
+      });
+    } else {
+      setReactState((prevState) => __spreadValues(__spreadValues({}, prevState), update));
+    }
+  }, []);
+  return [state, setState];
+};
+export {
+  useLocalState
+};