@ant-design/agentic-ui 2.0.0

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

@@ -0,0 +1,37 @@
+/**
+ * HTML to Markdown conversion utilities
+ * 无依赖的 HTML 到 Markdown 转换工具
+ */
+export interface HtmlToMarkdownOptions {
+    /** 是否保留换行符 */
+    preserveLineBreaks?: boolean;
+    /** 是否保留 HTML 注释 */
+    preserveComments?: boolean;
+    /** 图片处理函数 */
+    imageHandler?: (src: string, alt: string) => string;
+    /** 链接处理函数 */
+    linkHandler?: (href: string, text: string) => string;
+}
+/**
+ * 将 HTML 字符串转换为 Markdown
+ * @param html HTML 字符串
+ * @param options 转换选项
+ * @returns Markdown 字符串
+ */
+export declare function htmlToMarkdown(html: string, options?: HtmlToMarkdownOptions): string;
+/**
+ * 清理 HTML 字符串，移除不必要的空白和换行
+ */
+export declare function cleanHtml(html: string): string;
+/**
+ * 检测字符串是否为 HTML
+ */
+export declare function isHtml(text: string): boolean;
+/**
+ * 从 HTML 中提取纯文本
+ */
+export declare function extractTextFromHtml(html: string): string;
+/**
+ * 批量转换 HTML 片段为 Markdown
+ */
+export declare function batchHtmlToMarkdown(htmlFragments: string[], options?: HtmlToMarkdownOptions): string[];

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

@@ -0,0 +1,197 @@
+// src/MarkdownEditor/editor/utils/htmlToMarkdown.ts
+function convertNodeToMarkdown(node, options) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent || "";
+  }
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const element = node;
+    const tagName = element.tagName.toLowerCase();
+    return convertElementToMarkdown(element, tagName, options);
+  }
+  if (node.nodeType === Node.COMMENT_NODE) {
+    return options.preserveComments ? `<!--${node.textContent}-->` : "";
+  }
+  return "";
+}
+function convertLinkToMarkdown(element, text, options) {
+  const href = element.getAttribute("href") || "";
+  const linkText = text.trim();
+  if (options.linkHandler) {
+    return options.linkHandler(href, linkText);
+  }
+  return `[${linkText}](${href})`;
+}
+function convertImageToMarkdown(element, options) {
+  const src = element.getAttribute("src") || "";
+  const alt = element.getAttribute("alt") || "";
+  const title = element.getAttribute("title") || "";
+  if (options.imageHandler) {
+    return options.imageHandler(src, alt);
+  }
+  const titleAttr = title ? ` "${title}"` : "";
+  return `![${alt}](${src}${titleAttr})`;
+}
+function convertListToMarkdown(element, isOrdered, options) {
+  const items = Array.from(element.querySelectorAll("li"));
+  let result = "";
+  items.forEach((item, index) => {
+    const itemText = convertNodeToMarkdown(item, options).trim();
+    if (isOrdered) {
+      result += `${index + 1}. ${itemText}
+`;
+    } else {
+      result += `- ${itemText}
+`;
+    }
+  });
+  return result + "\n";
+}
+function convertTableToMarkdown(element, options) {
+  const rows = Array.from(element.querySelectorAll("tr"));
+  if (rows.length === 0)
+    return "";
+  let result = "";
+  const headerRow = rows[0];
+  const headerCells = Array.from(headerRow.querySelectorAll("th, td"));
+  result += "| " + headerCells.map((cell) => convertNodeToMarkdown(cell, options).trim()).join(" | ") + " |\n";
+  result += "| " + headerCells.map(() => "---").join(" | ") + " |\n";
+  for (let i = 1; i < rows.length; i++) {
+    const row = rows[i];
+    const cells = Array.from(row.querySelectorAll("td"));
+    result += "| " + cells.map((cell) => convertNodeToMarkdown(cell, options).trim()).join(" | ") + " |\n";
+  }
+  return result.trim() + "\n";
+}
+function convertTableRowToMarkdown(element, options) {
+  const cells = Array.from(element.querySelectorAll("th, td"));
+  return "| " + cells.map((cell) => convertNodeToMarkdown(cell, options).trim()).join(" | ") + " |\n";
+}
+function convertElementToMarkdown(element, tagName, options) {
+  const children = Array.from(element.childNodes).map((child) => convertNodeToMarkdown(child, options)).join("");
+  switch (tagName) {
+    case "h1":
+      return `# ${children}
+
+`;
+    case "h2":
+      return `## ${children}
+
+`;
+    case "h3":
+      return `### ${children}
+
+`;
+    case "h4":
+      return `#### ${children}
+
+`;
+    case "h5":
+      return `##### ${children}
+
+`;
+    case "h6":
+      return `###### ${children}
+
+`;
+    case "p":
+      return `${children}
+
+`;
+    case "br":
+      return "\n";
+    case "strong":
+    case "b":
+      return `**${children}**`;
+    case "em":
+    case "i":
+      return `*${children}*`;
+    case "del":
+    case "s":
+      return `~~${children}~~`;
+    case "code":
+      return `\`${children}\``;
+    case "pre": {
+      const codeElement = element.querySelector("code");
+      if (codeElement) {
+        const language = codeElement.className.replace("language-", "") || "";
+        return `\`\`\`${language}
+${codeElement.textContent || ""}
+\`\`\`
+
+`;
+      }
+      return `\`\`\`
+${element.textContent || ""}
+\`\`\`
+
+`;
+    }
+    case "blockquote":
+      return `> ${children.replace(/\n/g, "\n> ")}
+
+`;
+    case "ul":
+      return convertListToMarkdown(element, false, options);
+    case "ol":
+      return convertListToMarkdown(element, true, options);
+    case "li":
+      return `${children}
+`;
+    case "a":
+      return convertLinkToMarkdown(element, children, options);
+    case "img":
+      return convertImageToMarkdown(element, options);
+    case "table":
+      return convertTableToMarkdown(element, options);
+    case "tr":
+      return convertTableRowToMarkdown(element, options);
+    case "th":
+    case "td":
+      return children.trim();
+    case "hr":
+      return "---\n\n";
+    case "div":
+      return `${children}
+
+`;
+    case "span":
+      return children;
+    default:
+      return children;
+  }
+}
+function htmlToMarkdown(html, options = {}) {
+  if (!html || typeof html !== "string") {
+    return "";
+  }
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  return convertNodeToMarkdown(doc.body, options);
+}
+function cleanHtml(html) {
+  return html.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace(/\s+</g, "<").replace(/>\s+/g, ">").trim();
+}
+function isHtml(text) {
+  if (!text || text.trim() === "") {
+    return false;
+  }
+  const htmlTags = /<\/?[a-z][\s\S]*>/i;
+  return htmlTags.test(text);
+}
+function extractTextFromHtml(html) {
+  if (!html)
+    return "";
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  return doc.body.textContent || "";
+}
+function batchHtmlToMarkdown(htmlFragments, options = {}) {
+  return htmlFragments.map((fragment) => htmlToMarkdown(fragment, options));
+}
+export {
+  batchHtmlToMarkdown,
+  cleanHtml,
+  extractTextFromHtml,
+  htmlToMarkdown,
+  isHtml
+};

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

@@ -0,0 +1,98 @@
+import { HookAPI } from 'antd/es/modal/useModal';
+import React from 'react';
+import { Subject } from 'rxjs';
+export declare const nid: (size?: number | undefined) => string;
+export declare const sizeUnit: (size: number) => string;
+export declare const copy: <T = any>(data: T) => T;
+export declare const isMod: (e: MouseEvent | KeyboardEvent | React.KeyboardEvent | React.MouseEvent) => boolean;
+export declare function base64ToArrayBuffer(base64: string): ArrayBufferLike;
+export declare const getImageData: (filePath?: string) => string;
+export declare function toArrayBuffer(buffer: any): ArrayBuffer;
+export declare const download: (data: Blob | Uint8Array, fileName: string) => void;
+type ModalEvent<K extends keyof HookAPI> = {
+    type: K;
+    params: Parameters<HookAPI[K]>[0];
+};
+export declare const modal$: Subject<ModalEvent<"warning" | "info" | "error" | "success" | "confirm">>;
+export declare const encodeHtml: (str: string) => string;
+export { isMarkdown } from './isMarkdown';
+export declare function debounce(func: {
+    (): void;
+    apply?: any;
+}, delay: number | undefined): {
+    (): void;
+    flush(): void;
+    cancel(): void;
+};
+import { DependencyList } from 'react';
+export type UseTimeoutFnReturn = [() => boolean | null, () => void, () => void];
+/**
+ * 创建一个延时执行函数的Hook。
+ *
+ * @param fn - 需要延时执行的函数
+ * @param ms - 延时时间（毫秒），默认为0
+ * @returns 返回一个数组，包含三个元素：
+ * - isReady - 用于检查定时器是否已经触发的函数
+ * - clear - 用于清除定时器的函数
+ * - set - 用于重新设置定时器的函数
+ *
+ * @example
+ * ```ts
+ * const [isReady, clear, set] = useTimeoutFn(() => {
+ *   console.log('Timeout triggered');
+ * }, 1000);
+ * ```
+ *
+ * @remarks
+ * - 当组件挂载时，定时器会自动启动
+ * - 当传入的函数(fn)发生变化时，会自动更新回调函数
+ * - 当延时时间(ms)发生变化时，定时器会自动重置
+ * - 当组件卸载时，定时器会自动清除
+ */
+export declare function useTimeoutFn(fn: Function, ms?: number): UseTimeoutFnReturn;
+export type UseDebounceReturn = [() => boolean | null, () => void];
+/**
+ * 创建一个防抖函数的 Hook。
+ *
+ * @param fn - 需要进行防抖处理的函数
+ * @param ms - 防抖延迟时间(毫秒)。默认为0
+ * @param deps - 依赖数组，当依赖项改变时会重置防抖计时器。默认为空数组
+ * @returns 返回一个元组 [isReady, cancel]
+ *          - isReady: 一个函数，用于检查防抖是否已经准备好执行
+ *          - cancel: 一个函数，用于取消当前的防抖计时器
+ *
+ * @example
+ * ```typescript
+ * const [isReady, cancel] = useDebounce(() => {
+ *   // 执行一些操作
+ * }, 1000);
+ * ```
+ */
+export declare function useDebounce(fn: Function, ms?: number, deps?: DependencyList): UseDebounceReturn;
+export default function useUpdate(): () => void;
+export declare const useGetSetState: <T extends object>(initialState?: T) => [() => T, (patch: Partial<T>) => void];
+export declare function throttle(fn: any, wait: number): {
+    (): void;
+    flush(): void;
+    cancel(): void;
+};
+export declare const debugLog: (path: string, ...msg: any[]) => void;
+/**
+ * Markdown 编辑器事件常量对象
+ * @constant
+ * @description 包含编辑器的主要事件名称
+ * @property {string} SELECTIONCHANGE - 当编辑器选区发生变化时触发的事件名
+ * @property {string} FOCUS - 当编辑器获得焦点时触发的事件名
+ * @property {string} BLUR - 当编辑器失去焦点时触发的事件名
+ */
+export declare const MARKDOWN_EDITOR_EVENTS: {
+    SELECTIONCHANGE: string;
+    FOCUS: string;
+    BLUR: string;
+};
+export * from '../parser/parserSlateNodeToMarkdown';
+export * from './editorUtils';
+export * from './keyboard';
+export * from './media';
+export * from './path';
+export * from './useLocalState';

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

@@ -0,0 +1,233 @@
+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/index.ts
+import { customAlphabet } from "nanoid";
+import { Subject } from "rxjs";
+import { isMarkdown } from "./isMarkdown";
+import { useCallback, useEffect, useRef } from "react";
+import { useReducer } from "react";
+export * from "../parser/parserSlateNodeToMarkdown";
+export * from "./editorUtils";
+export * from "./keyboard";
+export * from "./media";
+export * from "./path";
+export * from "./useLocalState";
+var nid = customAlphabet(
+  "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  13
+);
+var kb = 1024;
+var mb = kb * 1024;
+var gb = mb * 1024;
+var sizeUnit = (size) => {
+  if (size > gb)
+    return (size / gb).toFixed(2) + " GB";
+  if (size > mb)
+    return (size / mb).toFixed(2) + " MB";
+  if (size > kb)
+    return (size / kb).toFixed(2) + " KB";
+  return size + " B";
+};
+var copy = (data) => JSON.parse(JSON.stringify(data));
+var isMod = (e) => {
+  return e.metaKey || e.ctrlKey;
+};
+function base64ToArrayBuffer(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+var getImageData = (filePath = "") => {
+  if (filePath.startsWith("data:image")) {
+    return filePath;
+  }
+  return filePath;
+};
+function toArrayBuffer(buffer) {
+  const arrayBuffer = new ArrayBuffer(buffer.length);
+  const view = new Uint8Array(arrayBuffer);
+  for (let i = 0; i < buffer.length; ++i) {
+    view[i] = buffer[i];
+  }
+  return arrayBuffer;
+}
+var download = (data, fileName) => {
+  data = data instanceof Uint8Array ? new Blob([data]) : data;
+  const link = document.createElement("a");
+  if (link.download !== void 0) {
+    const url = URL.createObjectURL(data);
+    link.addEventListener("click", (e) => e.stopPropagation());
+    link.setAttribute("href", url);
+    link.setAttribute("download", fileName);
+    link.style.visibility = "hidden";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  }
+};
+var modal$ = new Subject();
+var encodeHtml = (str) => {
+  const encodeHTMLRules = {
+    "&": "&#38;",
+    "<": "&#60;",
+    ">": "&#62;",
+    '"': "&#34;",
+    "'": "&#39;",
+    "/": "&#47;"
+  }, matchHTML = /&(?!#?\w+;)|<|>|"|'|\//g;
+  return str.replace(matchHTML, function(m) {
+    return encodeHTMLRules[m] || m;
+  });
+};
+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;
+}
+function useTimeoutFn(fn, ms = 0) {
+  const ready = useRef(false);
+  const timeout = useRef();
+  const callback = useRef(fn);
+  const isReady = useCallback(() => ready.current, []);
+  const set = useCallback(() => {
+    ready.current = false;
+    timeout.current && clearTimeout(timeout.current);
+    timeout.current = setTimeout(() => {
+      ready.current = true;
+      callback.current();
+    }, ms);
+  }, [ms]);
+  const clear = useCallback(() => {
+    ready.current = null;
+    timeout.current && clearTimeout(timeout.current);
+  }, []);
+  useEffect(() => {
+    callback.current = fn;
+  }, [fn]);
+  useEffect(() => {
+    set();
+    return clear;
+  }, [ms]);
+  return [isReady, clear, set];
+}
+function useDebounce(fn, ms = 0, deps = []) {
+  const [isReady, cancel, reset] = useTimeoutFn(fn, ms);
+  useEffect(reset, deps);
+  return [isReady, cancel];
+}
+var updateReducer = (num) => (num + 1) % 1e6;
+function useUpdate() {
+  const [, update] = useReducer(updateReducer, 0);
+  return update;
+}
+var useGetSetState = (initialState = {}) => {
+  if (true) {
+    if (typeof initialState !== "object") {
+      console.error("useGetSetState initial state must be an object.");
+    }
+  }
+  const update = useUpdate();
+  const state = useRef(__spreadValues({}, initialState));
+  const get = useCallback(() => state.current, []);
+  const set = useCallback((patch) => {
+    if (!patch) {
+      return;
+    }
+    if (true) {
+      if (typeof patch !== "object") {
+        console.error("useGetSetState setter patch must be an object.");
+      }
+    }
+    Object.assign(state.current, patch);
+    update();
+  }, []);
+  return [get, set];
+};
+function throttle(fn, wait) {
+  let pre = Date.now();
+  const runFn = function() {
+    let context = this;
+    let args = arguments;
+    let now = Date.now();
+    if (now - pre >= wait) {
+      fn.apply(context, args);
+      pre = Date.now();
+    }
+  };
+  runFn.flush = function() {
+    {
+      pre = Date.now();
+      fn.apply(this, arguments);
+    }
+  };
+  runFn.cancel = function() {
+    pre = Date.now();
+  };
+  return runFn;
+}
+var debugLog = (path, ...msg) => {
+  if (typeof window === "undefined")
+    return;
+  if (window == null ? void 0 : window.debug) {
+    console.log(`debug「${path}」--->`, ...msg);
+  }
+};
+var MARKDOWN_EDITOR_EVENTS = {
+  // 编辑器选区发生变化时触发的事件名
+  SELECTIONCHANGE: "md-editor-selectionchange",
+  // 编辑器获得焦点时触发的事件名
+  FOCUS: "md-editor-focus",
+  // 编辑器失去焦点时触发的事件名
+  BLUR: "md-editor-blur"
+};
+export {
+  MARKDOWN_EDITOR_EVENTS,
+  base64ToArrayBuffer,
+  copy,
+  debounce,
+  debugLog,
+  useUpdate as default,
+  download,
+  encodeHtml,
+  getImageData,
+  isMarkdown,
+  isMod,
+  modal$,
+  nid,
+  sizeUnit,
+  throttle,
+  toArrayBuffer,
+  useDebounce,
+  useGetSetState,
+  useTimeoutFn
+};

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

@@ -0,0 +1,6 @@
+/**
+ * Check if a string contains Markdown formatting
+ * @param text String to check
+ * @returns Boolean indicating if the text contains Markdown formatting
+ */
+export declare function isMarkdown(text: string): boolean;

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

@@ -0,0 +1,46 @@
+// src/MarkdownEditor/editor/utils/isMarkdown.ts
+function isMarkdown(text) {
+  if (!text || text.trim() === "") {
+    return false;
+  }
+  if (/^#+\s+.+/m.test(text)) {
+    return true;
+  }
+  if (/\|.+\|[\r\n]+\|[\s-:]+\|/m.test(text)) {
+    return true;
+  }
+  if (/\[.+\]\(.+\)/.test(text)) {
+    return true;
+  }
+  if (/!\[.+\]\(.+\)/.test(text)) {
+    return true;
+  }
+  if (/```[\s\S]*```/.test(text)) {
+    return true;
+  }
+  if (/`.+`/.test(text)) {
+    return true;
+  }
+  if (/^>\s+.+/m.test(text)) {
+    return true;
+  }
+  if (/\*\*.+\*\*/.test(text) || /__.+__/.test(text)) {
+    return true;
+  }
+  if (/\*.+\*/.test(text) && !/^\*$/.test(text)) {
+    return true;
+  }
+  if (/~~.+~~/.test(text)) {
+    return true;
+  }
+  if (/^(---|===|\*\*\*)$/m.test(text)) {
+    return true;
+  }
+  if (/[^\\|]\|[^\\|][\r\n]+[-|]+[\r\n]+[^\\|]\|[^\\|]/.test(text)) {
+    return true;
+  }
+  return false;
+}
+export {
+  isMarkdown
+};