@will1123/lx-ui-utils 1.0.0

package/dist/dist/index.esm.js

@@ -0,0 +1,618 @@
+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 __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());
+  });
+};
+class SSEConnection {
+  constructor() {
+    this.controller = null;
+    this.eventSource = null;
+    this.timeoutTimer = null;
+  }
+  /**
+   * 发起 SSE 请求
+   */
+  request(config, handlers) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      const { url, method = "GET", headers = {}, body, timeout = 3e4 } = config;
+      this.controller = new AbortController();
+      try {
+        if (timeout > 0) {
+          this.timeoutTimer = setTimeout(() => {
+            var _a2;
+            this.close();
+            (_a2 = handlers.onError) == null ? void 0 : _a2.call(handlers, new Error(`Request timeout after ${timeout}ms`));
+          }, timeout);
+        }
+        const response = yield fetch(url, {
+          method,
+          headers: __spreadValues({
+            "Content-Type": "application/json"
+          }, headers),
+          body: method === "POST" ? JSON.stringify(body) : void 0,
+          signal: this.controller.signal
+        });
+        if (this.timeoutTimer) {
+          clearTimeout(this.timeoutTimer);
+          this.timeoutTimer = null;
+        }
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const contentType = response.headers.get("content-type");
+        if (!(contentType == null ? void 0 : contentType.includes("text/event-stream"))) {
+          throw new Error("Response is not a Server-Sent Events stream");
+        }
+        (_a = handlers.onOpen) == null ? void 0 : _a.call(handlers);
+        const reader = (_b = response.body) == null ? void 0 : _b.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        if (!reader) {
+          throw new Error("Response body is null");
+        }
+        while (true) {
+          const { done, value } = yield reader.read();
+          if (done) {
+            (_c = handlers.onClose) == null ? void 0 : _c.call(handlers);
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.trim()) {
+              const message = this.parseMessage(line);
+              (_d = handlers.onMessage) == null ? void 0 : _d.call(handlers, message);
+            }
+          }
+        }
+      } catch (error) {
+        if (this.timeoutTimer) {
+          clearTimeout(this.timeoutTimer);
+          this.timeoutTimer = null;
+        }
+        if (this.controller && !this.controller.signal.aborted) {
+          (_e = handlers.onError) == null ? void 0 : _e.call(handlers, error);
+        }
+      }
+    });
+  }
+  /**
+   * 使用 EventSource 连接（仅支持 GET 请求）
+   */
+  connect(url, handlers) {
+    this.eventSource = new EventSource(url);
+    this.eventSource.onopen = () => {
+      var _a;
+      (_a = handlers.onOpen) == null ? void 0 : _a.call(handlers);
+    };
+    this.eventSource.onmessage = (event) => {
+      var _a;
+      (_a = handlers.onMessage) == null ? void 0 : _a.call(handlers, {
+        data: event.data,
+        event: event.type
+      });
+    };
+    this.eventSource.onerror = (error) => {
+      var _a;
+      (_a = handlers.onError) == null ? void 0 : _a.call(handlers, new Error("EventSource error"));
+      this.close();
+    };
+  }
+  /**
+   * 解析 SSE 消息
+   */
+  parseMessage(line) {
+    const message = {
+      data: ""
+    };
+    const lines = line.split("\n");
+    for (const l of lines) {
+      if (l.startsWith("data: ")) {
+        message.data = l.slice(6);
+      } else if (l.startsWith("event: ")) {
+        message.event = l.slice(7);
+      } else if (l.startsWith("id: ")) {
+        message.id = l.slice(4);
+      } else if (l.startsWith("retry: ")) {
+        message.retry = parseInt(l.slice(7));
+      }
+    }
+    return message;
+  }
+  /**
+   * 关闭连接
+   */
+  close() {
+    if (this.controller) {
+      this.controller.abort();
+      this.controller = null;
+    }
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+  }
+}
+function sse(config, handlers) {
+  const connection = new SSEConnection();
+  if (config.method === "POST" || config.timeout) {
+    connection.request(config, handlers);
+  } else {
+    connection.connect(config.url, handlers);
+  }
+  return connection;
+}
+function extractThinking(text, config = {}) {
+  const { tagName = "think", includeTags = false, removeRest = false } = config;
+  const openTag = `<${tagName}>`;
+  const closeTag = `</${tagName}>`;
+  const openIndex = text.indexOf(openTag);
+  const closeIndex = text.indexOf(closeTag);
+  if (openIndex === -1 || closeIndex === -1) {
+    return {
+      thinking: "",
+      rest: text,
+      hasThinking: false
+    };
+  }
+  const thinkingStart = openIndex + openTag.length;
+  const thinkingEnd = closeIndex;
+  const thinkingContent = text.slice(thinkingStart, thinkingEnd);
+  const beforeContent = text.slice(0, openIndex);
+  const afterContent = text.slice(closeIndex + closeTag.length);
+  const restContent = beforeContent + afterContent;
+  return {
+    thinking: includeTags ? `${openTag}${thinkingContent}${closeTag}` : thinkingContent,
+    rest: removeRest ? "" : restContent,
+    hasThinking: true
+  };
+}
+class ThinkingStreamExtractor {
+  constructor(config = {}) {
+    this.isComplete = false;
+    this.config = {
+      tagName: config.tagName || "think",
+      includeTags: config.includeTags || false,
+      removeRest: config.removeRest || false
+    };
+    this.state = {
+      inThinking: false,
+      tagBuffer: "",
+      contentBuffer: "",
+      beforeContent: "",
+      afterContent: ""
+    };
+  }
+  /**
+   * 追加文本并提取思考内容
+   */
+  append(text) {
+    if (this.isComplete) {
+      return {
+        thinking: this.getThinking(),
+        rest: this.getRest(),
+        isComplete: true
+      };
+    }
+    const { tagName } = this.config;
+    const openTag = `<${tagName}>`;
+    const closeTag = `</${tagName}>`;
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (!this.state.inThinking) {
+        this.state.tagBuffer += char;
+        if (this.state.tagBuffer.endsWith(openTag)) {
+          const tagStart = this.state.tagBuffer.length - openTag.length;
+          this.state.beforeContent += this.state.tagBuffer.slice(0, tagStart);
+          this.state.tagBuffer = "";
+          this.state.inThinking = true;
+          continue;
+        }
+        if (this.state.tagBuffer.length > openTag.length) {
+          this.state.beforeContent += this.state.tagBuffer.slice(0, 1);
+          this.state.tagBuffer = this.state.tagBuffer.slice(1);
+        }
+      } else {
+        this.state.tagBuffer += char;
+        if (this.state.tagBuffer.endsWith(closeTag)) {
+          const tagEnd = this.state.tagBuffer.length - closeTag.length;
+          this.state.contentBuffer += this.state.tagBuffer.slice(0, tagEnd);
+          this.state.tagBuffer = "";
+          this.state.inThinking = false;
+          this.isComplete = true;
+          break;
+        }
+        if (this.state.tagBuffer.length > closeTag.length) {
+          const overflow = this.state.tagBuffer.slice(0, 1);
+          this.state.contentBuffer += overflow;
+          this.state.tagBuffer = this.state.tagBuffer.slice(1);
+        }
+      }
+    }
+    if (!this.state.inThinking && this.state.tagBuffer) {
+      if (this.isComplete) {
+        this.state.afterContent += this.state.tagBuffer;
+      } else {
+        this.state.beforeContent += this.state.tagBuffer;
+      }
+      this.state.tagBuffer = "";
+    }
+    return {
+      thinking: this.getThinking(),
+      rest: this.getRest(),
+      isComplete: this.isComplete
+    };
+  }
+  /**
+   * 获取当前提取的思考内容
+   */
+  getThinking() {
+    const { tagName, includeTags } = this.config;
+    const openTag = `<${tagName}>`;
+    const closeTag = `</${tagName}>`;
+    const content = this.state.contentBuffer;
+    if (includeTags) {
+      return this.state.inThinking ? `${openTag}${content}` : `${openTag}${content}${closeTag}`;
+    }
+    return content;
+  }
+  /**
+   * 获取剩余内容
+   */
+  getRest() {
+    const { removeRest } = this.config;
+    if (removeRest) {
+      return "";
+    }
+    return this.state.beforeContent + this.state.afterContent;
+  }
+  /**
+   * 是否已完成提取
+   */
+  complete() {
+    return this.isComplete;
+  }
+  /**
+   * 重置提取器
+   */
+  reset() {
+    this.state = {
+      inThinking: false,
+      tagBuffer: "",
+      contentBuffer: "",
+      beforeContent: "",
+      afterContent: ""
+    };
+    this.isComplete = false;
+  }
+}
+function createThinkingExtractor(config) {
+  return new ThinkingStreamExtractor(config);
+}
+class MarkdownRenderer {
+  constructor(config = {}) {
+    this.config = {
+      highlight: config.highlight || false,
+      highlightLanguages: config.highlightLanguages || {},
+      taskList: config.taskList !== false,
+      table: config.table !== false,
+      link: config.link !== false,
+      image: config.image !== false
+    };
+  }
+  /**
+   * 渲染 Markdown 为 HTML
+   */
+  render(markdown) {
+    let html = markdown;
+    html = this.escapeHtml(html);
+    html = this.renderCodeBlocks(html);
+    html = this.renderHeadings(html);
+    html = this.renderEmphasis(html);
+    if (this.config.taskList) {
+      html = this.renderTaskLists(html);
+    }
+    html = this.renderUnorderedLists(html);
+    html = this.renderOrderedLists(html);
+    if (this.config.table) {
+      html = this.renderTables(html);
+    }
+    if (this.config.link) {
+      html = this.renderLinks(html);
+    }
+    if (this.config.image) {
+      html = this.renderImages(html);
+    }
+    html = this.renderParagraphs(html);
+    html = this.renderLineBreaks(html);
+    return html;
+  }
+  /**
+   * 转义 HTML 特殊字符
+   */
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  /**
+   * 渲染代码块
+   */
+  renderCodeBlocks(text) {
+    return text.replace(
+      /`{3}(\w*)\n([\s\S]*?)`{3}/g,
+      (match, lang, code) => {
+        const language = lang || "text";
+        return `<pre><code class="language-${language}">${code.trim()}</code></pre>`;
+      }
+    );
+  }
+  /**
+   * 渲染标题
+   */
+  renderHeadings(text) {
+    return text.replace(/^#{6}\s+(.+)$/gm, "<h6>$1</h6>").replace(/^#{5}\s+(.+)$/gm, "<h5>$1</h5>").replace(/^#{4}\s+(.+)$/gm, "<h4>$1</h4>").replace(/^#{3}\s+(.+)$/gm, "<h3>$1</h3>").replace(/^#{2}\s+(.+)$/gm, "<h2>$1</h2>").replace(/^#{1}\s+(.+)$/gm, "<h1>$1</h1>");
+  }
+  /**
+   * 渲染粗体和斜体
+   */
+  renderEmphasis(text) {
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "<strong><em>$1</em></strong>");
+    text = text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+    text = text.replace(/___(.+?)___/g, "<strong><em>$1</em></strong>");
+    text = text.replace(/__(.+?)__/g, "<strong>$1</strong>");
+    text = text.replace(/\*(.+?)\*/g, "<em>$1</em>");
+    text = text.replace(/_(.+?)_/g, "<em>$1</em>");
+    return text;
+  }
+  /**
+   * 渲染任务列表
+   */
+  renderTaskLists(text) {
+    return text.replace(/^\s*-\s*\[x\]\s+(.+)$/gm, '<li class="task-checked"><input type="checkbox" checked disabled> $1</li>').replace(/^\s*-\s*\[\s*\]\s+(.+)$/gm, '<li><input type="checkbox" disabled> $1</li>');
+  }
+  /**
+   * 渲染无序列表
+   */
+  renderUnorderedLists(text) {
+    const lines = text.split("\n");
+    const result = [];
+    const listStack = [];
+    for (const line of lines) {
+      const match = line.match(/^(\s*)-\s+(.+)$/);
+      if (!match) {
+        while (listStack.length > 0) {
+          result.push(listStack.pop() || "");
+        }
+        result.push(line);
+        continue;
+      }
+      const [_, indent, content] = match;
+      const indentLevel = indent.length;
+      while (listStack.length > 0 && listStack.length < indentLevel / 2 + 1) {
+        result.push(listStack.pop() || "");
+      }
+      while (listStack.length < indentLevel / 2 + 1) {
+        listStack.push("<ul>");
+        result.push("<ul>");
+      }
+      result.push(`<li>${content}</li>`);
+    }
+    while (listStack.length > 0) {
+      result.push("</ul>");
+      listStack.pop();
+    }
+    return result.join("\n");
+  }
+  /**
+   * 渲染有序列表
+   */
+  renderOrderedLists(text) {
+    const lines = text.split("\n");
+    const result = [];
+    let inList = false;
+    for (const line of lines) {
+      const match = line.match(/^\s*\d+\.\s+(.+)$/);
+      if (!match) {
+        if (inList) {
+          result.push("</ol>");
+          inList = false;
+        }
+        result.push(line);
+        continue;
+      }
+      const [_, content] = match;
+      if (!inList) {
+        result.push("<ol>");
+        inList = true;
+      }
+      result.push(`<li>${content}</li>`);
+    }
+    if (inList) {
+      result.push("</ol>");
+    }
+    return result.join("\n");
+  }
+  /**
+   * 渲染表格
+   */
+  renderTables(text) {
+    const lines = text.split("\n");
+    const result = [];
+    let inTable = false;
+    let headerRendered = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.match(/^\|[\s\-:|]+\|$/)) {
+        continue;
+      }
+      const match = line.match(/^\|(.+)\|$/);
+      if (!match) {
+        if (inTable) {
+          result.push("</table>");
+          inTable = false;
+          headerRendered = false;
+        }
+        result.push(line);
+        continue;
+      }
+      const cells = match[1].split("|").map((cell) => cell.trim());
+      if (!inTable) {
+        result.push("<table>");
+        inTable = true;
+      }
+      if (!headerRendered) {
+        result.push("<thead><tr>");
+        cells.forEach((cell) => {
+          result.push(`<th>${cell}</th>`);
+        });
+        result.push("</tr></thead><tbody>");
+        headerRendered = true;
+      } else {
+        result.push("<tr>");
+        cells.forEach((cell) => {
+          result.push(`<td>${cell}</td>`);
+        });
+        result.push("</tr>");
+      }
+    }
+    if (inTable) {
+      result.push("</tbody></table>");
+    }
+    return result.join("\n");
+  }
+  /**
+   * 渲染链接
+   */
+  renderLinks(text) {
+    return text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank">$1</a>');
+  }
+  /**
+   * 渲染图片
+   */
+  renderImages(text) {
+    return text.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" />');
+  }
+  /**
+   * 渲染段落
+   */
+  renderParagraphs(text) {
+    const lines = text.split("\n");
+    const result = [];
+    let inParagraph = false;
+    for (const line of lines) {
+      if (!line.trim() || line.match(/^<(h|ul|ol|li|table|pre|div)/)) {
+        if (inParagraph) {
+          result.push("</p>");
+          inParagraph = false;
+        }
+        result.push(line);
+        continue;
+      }
+      if (!inParagraph) {
+        result.push("<p>");
+        inParagraph = true;
+      }
+      result.push(line);
+    }
+    if (inParagraph) {
+      result.push("</p>");
+    }
+    return result.join("\n");
+  }
+  /**
+   * 渲染换行
+   */
+  renderLineBreaks(text) {
+    return text.replace(/(<p>.*?<\/p>|<li>.*?<\/li>)/g, (match) => {
+      return match.replace(/\n/g, "<br>\n");
+    });
+  }
+}
+function renderMarkdown(markdown, config) {
+  const renderer = new MarkdownRenderer(config);
+  return renderer.render(markdown);
+}
+class MarkdownStreamRenderer {
+  constructor(config = {}) {
+    this.buffer = "";
+    this.config = config;
+    this.renderer = new MarkdownRenderer(config);
+  }
+  /**
+   * 追加文本并渲染
+   */
+  append(text) {
+    this.buffer += text;
+    const html = this.renderer.render(this.buffer);
+    if (this.config.onUpdate) {
+      this.config.onUpdate(html);
+    }
+    return html;
+  }
+  /**
+   * 完成渲染
+   */
+  complete() {
+    const html = this.renderer.render(this.buffer);
+    if (this.config.onComplete) {
+      this.config.onComplete(html);
+    }
+    return html;
+  }
+  /**
+   * 重置渲染器
+   */
+  reset() {
+    this.buffer = "";
+  }
+}
+function createMarkdownRenderer(config) {
+  return new MarkdownStreamRenderer(config);
+}
+export {
+  MarkdownRenderer,
+  MarkdownStreamRenderer,
+  SSEConnection,
+  ThinkingStreamExtractor,
+  createMarkdownRenderer,
+  createThinkingExtractor,
+  extractThinking,
+  renderMarkdown,
+  sse
+};