@yh-ui/request 0.1.21

package/dist/useSSE.d.ts

@@ -0,0 +1,74 @@
+import { type Ref, type ShallowRef } from 'vue';
+import { type RequestOptions } from './types';
+/** SSE 事件类型 */
+export type SSEEventType = 'message' | 'start' | 'chunk' | 'done' | 'error' | 'tool' | 'thinking' | 'custom';
+/** SSE 消息 */
+export interface SSEMessage<T = unknown> {
+    /** 事件类型 */
+    event: SSEEventType;
+    /** 数据 */
+    data: T;
+    /** 原始行数据 */
+    raw: string;
+    /** 是否为最后一个消息 */
+    done: boolean;
+    /** 错误信息（如有） */
+    error?: Error;
+}
+/** SSE Hook 配置 */
+export interface UseSSEOptions extends RequestOptions {
+    /** 自动解析 JSON */
+    parseJSON?: boolean;
+    /** 解码器 */
+    decoder?: TextDecoder;
+    /** 消息分隔符 */
+    separator?: string;
+    /** 自定义事件前缀 */
+    eventPrefix?: string;
+    /** 开始回调 */
+    onStart?: () => void;
+    /** 消息回调 */
+    onMessage?: (message: SSEMessage) => void;
+    /** 完成回调 */
+    onDone?: (fullContent: string) => void;
+    /** 错误回调 */
+    onError?: (error: Error) => void;
+    /** 自定义事件回调 */
+    onCustomEvent?: (event: string, data: unknown) => void;
+}
+/** SSE Hook 返回值 */
+export interface UseSSEReturn {
+    /** 是否正在连接/接收 */
+    loading: Ref<boolean>;
+    /** 当前接收到的文本 */
+    content: Ref<string>;
+    /** 完整消息列表 */
+    messages: Ref<SSEMessage[]>;
+    /** 错误 */
+    error: ShallowRef<Error | undefined>;
+    /** 启动流式请求 */
+    start: (options?: RequestOptions) => void;
+    /** 停止流式请求 */
+    stop: () => void;
+    /** 重置状态 */
+    reset: () => void;
+}
+/**
+ * useSSE - Server-Sent Events 流式请求 Hook
+ *
+ * 适用于 AI 应用中的流式响应
+ *
+ * @example
+ * const { content, loading, messages, start, stop } = useSSE({
+ *   onMessage: (msg) => console.log(msg.data),
+ *   onDone: (full) => console.log('Complete:', full),
+ * })
+ *
+ * // 发起请求
+ * start({
+ *   url: '/api/chat',
+ *   method: 'POST',
+ *   data: { messages: [...] },
+ * })
+ */
+export declare function useSSE(options?: UseSSEOptions): UseSSEReturn;

package/dist/useSSE.mjs

@@ -0,0 +1,226 @@
+import { ref, shallowRef, onUnmounted } from "vue";
+export function useSSE(options = {}) {
+  const {
+    parseJSON = true,
+    separator = "\n\n",
+    eventPrefix = "event:",
+    onStart,
+    onMessage,
+    onDone,
+    onError,
+    onCustomEvent,
+    ...fetchOptions
+  } = options;
+  const loading = ref(false);
+  const content = ref("");
+  const messages = ref([]);
+  const error = shallowRef(void 0);
+  let abortController = null;
+  let reader = null;
+  let decoder;
+  const getDecoder = () => {
+    if (!decoder) {
+      decoder = new TextDecoder();
+    }
+    return decoder;
+  };
+  const parseLine = (line) => {
+    const result = { data: "" };
+    if (!line || line.startsWith("#")) return result;
+    if (line.startsWith(eventPrefix)) {
+      result.event = line.slice(eventPrefix.length).trim();
+      return result;
+    }
+    if (line.startsWith("data:")) {
+      const data = line.slice(5);
+      result.data = data.startsWith(" ") ? data.slice(1) : data;
+    }
+    return result;
+  };
+  const parseSSE = (rawData) => {
+    const lines = rawData.split("\n");
+    let originalEventType = "message";
+    let eventData = "";
+    let done = false;
+    for (const line of lines) {
+      const { event, data } = parseLine(line);
+      if (event) originalEventType = event;
+      if (data) eventData += data;
+    }
+    let eventType = "message";
+    switch (originalEventType.toLowerCase()) {
+      case "start":
+        eventType = "start";
+        break;
+      case "message":
+      case "chunk":
+      case "content":
+        eventType = "chunk";
+        break;
+      case "done":
+      case "stop":
+        eventType = "done";
+        done = true;
+        break;
+      case "error":
+        eventType = "error";
+        break;
+      case "tool":
+      case "function":
+        eventType = "tool";
+        break;
+      case "thinking":
+      case "thinking_start":
+      case "thinking_end":
+        eventType = "thinking";
+        break;
+      default:
+        eventType = "custom";
+        break;
+    }
+    if (!eventData && eventType !== "done" && eventType !== "start") return null;
+    let finalData = eventData;
+    if (parseJSON && eventData) {
+      try {
+        finalData = JSON.parse(eventData);
+      } catch {
+      }
+    }
+    if (eventType === "custom" && onCustomEvent) {
+      onCustomEvent(originalEventType, finalData);
+    }
+    return {
+      event: eventType,
+      data: finalData,
+      raw: rawData,
+      done
+    };
+  };
+  const start = async (requestOptions) => {
+    stop();
+    reset();
+    const config = {
+      ...fetchOptions,
+      ...requestOptions
+    };
+    loading.value = true;
+    error.value = void 0;
+    onStart?.();
+    try {
+      let url = config.url || "";
+      if (config.baseURL) {
+        url = url.startsWith("http") ? url : config.baseURL + url;
+      }
+      if (config.params) {
+        const params = new URLSearchParams();
+        Object.entries(config.params).forEach(([key, value]) => {
+          if (Array.isArray(value)) {
+            value.forEach((v) => params.append(key, String(v)));
+          } else {
+            params.append(key, String(value));
+          }
+        });
+        const sep = url.includes("?") ? "&" : "?";
+        url += sep + params.toString();
+      }
+      const headers = config.headers || {};
+      const fetchInit = {
+        method: config.method || "POST",
+        headers,
+        credentials: config.credentials || "same-origin"
+      };
+      if (config.data && config.method !== "GET") {
+        fetchInit.body = JSON.stringify(config.data);
+        if (!headers["Content-Type"]) {
+          headers["Content-Type"] = "application/json";
+        }
+      }
+      abortController = new AbortController();
+      fetchInit.signal = abortController.signal;
+      const response = await fetch(url, fetchInit);
+      if (!response.ok) {
+        throw new Error(`SSE request failed: ${response.status} ${response.statusText}`);
+      }
+      const body = response.body;
+      if (!body) {
+        throw new Error("Response body is null");
+      }
+      reader = body.getReader();
+      const textDecoder = getDecoder();
+      let buffer = "";
+      while (true) {
+        const { done: readDone, value } = await reader.read();
+        if (readDone) {
+          if (buffer) {
+            const msg = parseSSE(buffer);
+            if (msg) {
+              handleMessage(msg);
+            }
+          }
+          break;
+        }
+        const chunk = textDecoder.decode(value, { stream: true });
+        buffer += chunk;
+        const parts = buffer.split(separator);
+        buffer = parts.pop() || "";
+        for (const part of parts) {
+          const msg = parseSSE(part);
+          if (msg) {
+            handleMessage(msg);
+            if (msg.done) {
+              onDone?.(content.value);
+              loading.value = false;
+              return;
+            }
+          }
+        }
+      }
+      onDone?.(content.value);
+    } catch (err) {
+      const errWithName = err;
+      if (errWithName?.name === "AbortError") {
+        return;
+      }
+      const errObj = err instanceof Error ? err : new Error(String(err));
+      error.value = errObj;
+      onError?.(errObj);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const handleMessage = (message) => {
+    if (typeof message.data === "string") {
+      content.value += message.data;
+    }
+    messages.value.push(message);
+    onMessage?.(message);
+  };
+  const stop = () => {
+    if (reader) {
+      reader.cancel();
+      reader = null;
+    }
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    loading.value = false;
+  };
+  const reset = () => {
+    content.value = "";
+    messages.value = [];
+    error.value = void 0;
+  };
+  onUnmounted(() => {
+    stop();
+  });
+  return {
+    loading,
+    content,
+    messages,
+    error,
+    start,
+    stop,
+    reset
+  };
+}

package/dist/websocket.cjs

@@ -0,0 +1,325 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebSocketClient = void 0;
+exports.createWebSocket = createWebSocket;
+exports.isWebSocketSupported = isWebSocketSupported;
+exports.useWebSocket = useWebSocket;
+var _vue = require("vue");
+class WebSocketClient {
+  ws = null;
+  url = "";
+  protocols;
+  options;
+  // 状态
+  _state = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  heartbeatTimeoutTimer = null;
+  messageQueue = [];
+  // 回调
+  onOpenCallback = null;
+  onCloseCallback = null;
+  onErrorCallback = null;
+  onMessageCallback = null;
+  onStateChangeCallback = null;
+  // 响应式状态 (供 Vue 使用)
+  state;
+  isConnected;
+  lastMessage;
+  constructor(options) {
+    this.url = options.url;
+    this.protocols = options.protocols;
+    this.options = {
+      url: options.url,
+      protocols: options.protocols,
+      reconnect: options.reconnect ?? true,
+      reconnectMaxAttempts: options.reconnectMaxAttempts ?? 10,
+      reconnectInterval: options.reconnectInterval ?? 1e3,
+      reconnectMaxDelay: options.reconnectMaxDelay ?? 3e4,
+      heartbeat: options.heartbeat ?? false,
+      heartbeatInterval: options.heartbeatInterval ?? 3e4,
+      heartbeatTimeout: options.heartbeatTimeout ?? 1e4,
+      headers: options.headers ?? {},
+      binaryType: options.binaryType ?? "blob",
+      encode: options.encode ?? (data => JSON.stringify(data)),
+      decode: options.decode ?? (data => {
+        if (typeof data === "string") {
+          try {
+            return JSON.parse(data);
+          } catch {
+            return data;
+          }
+        }
+        return data;
+      })
+    };
+    this.state = (0, _vue.ref)("disconnected");
+    this.isConnected = (0, _vue.ref)(false);
+    this.lastMessage = (0, _vue.ref)(null);
+    this.handleOpen = this.handleOpen.bind(this);
+    this.handleClose = this.handleClose.bind(this);
+    this.handleError = this.handleError.bind(this);
+    this.handleMessage = this.handleMessage.bind(this);
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return this._state;
+  }
+  /**
+   * 设置状态
+   */
+  setState(newState) {
+    this._state = newState;
+    this.state.value = newState;
+    this.isConnected.value = newState === "connected";
+    this.onStateChangeCallback?.(newState);
+  }
+  /**
+   * 连接
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (!isWebSocketSupported()) {
+        const error = new Error("WebSocket is not supported in this environment");
+        this.setState("error");
+        reject(error);
+        return;
+      }
+      const CONNECTING = 0;
+      const OPEN = 1;
+      if (this.ws && (this.ws.readyState === OPEN || this.ws.readyState === CONNECTING)) {
+        resolve();
+        return;
+      }
+      this.setState("connecting");
+      try {
+        this.ws = this.protocols ? new WebSocket(this.url, this.protocols) : new WebSocket(this.url);
+        this.ws.binaryType = this.options.binaryType;
+        this.ws.onopen = event => {
+          this.handleOpen(event);
+          resolve();
+        };
+        this.ws.onclose = this.handleClose;
+        this.ws.onerror = this.handleError;
+        this.ws.onmessage = this.handleMessage;
+      } catch (error) {
+        this.setState("error");
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 断开连接
+   */
+  disconnect(code = 1e3, reason = "Client disconnect") {
+    this.clearTimers();
+    this.setState("disconnecting");
+    if (this.ws) {
+      this.ws.close(code, reason);
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  /**
+   * 发送消息
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.messageQueue.push(this.options.encode(data));
+      return false;
+    }
+    const encoded = this.options.encode(data);
+    this.ws.send(encoded);
+    return true;
+  }
+  /**
+   * 发送并等待响应
+   */
+  sendAndWait(data, timeout = 3e4) {
+    return new Promise((resolve, reject) => {
+      const messageId = Date.now().toString();
+      const timer = setTimeout(() => {
+        reject(new Error("WebSocket message timeout"));
+      }, timeout);
+      const originalCallback = this.onMessageCallback;
+      this.onMessageCallback = message => {
+        const decoded = message.data;
+        if (decoded && decoded.id === messageId) {
+          clearTimeout(timer);
+          this.onMessageCallback = originalCallback;
+          resolve(decoded.result);
+        } else {
+          originalCallback?.(message);
+        }
+      };
+      this.send({
+        id: messageId,
+        ...data
+      });
+    });
+  }
+  /**
+   * 事件回调
+   */
+  onOpen(callback) {
+    this.onOpenCallback = callback;
+    return this;
+  }
+  onClose(callback) {
+    this.onCloseCallback = callback;
+    return this;
+  }
+  onError(callback) {
+    this.onErrorCallback = callback;
+    return this;
+  }
+  onMessage(callback) {
+    this.onMessageCallback = callback;
+    return this;
+  }
+  onStateChange(callback) {
+    this.onStateChangeCallback = callback;
+    return this;
+  }
+  // ==================== 内部方法 ====================
+  handleOpen(_event) {
+    this.setState("connected");
+    this.reconnectAttempts = 0;
+    while (this.messageQueue.length > 0) {
+      const data = this.messageQueue.shift();
+      if (data && this.ws) {
+        this.ws.send(data);
+      }
+    }
+    if (this.options.heartbeat) {
+      this.startHeartbeat();
+    }
+    this.onOpenCallback?.();
+  }
+  handleClose(event) {
+    this.ws = null;
+    this.clearTimers();
+    this.setState("disconnected");
+    if (this.options.reconnect && this.reconnectAttempts < this.options.reconnectMaxAttempts) {
+      this.reconnect();
+    }
+    this.onCloseCallback?.(event.code, event.reason);
+  }
+  handleError(event) {
+    this.setState("error");
+    this.onErrorCallback?.(event);
+  }
+  handleMessage(event) {
+    const raw = event.data;
+    let data;
+    if (event.data === "pong") {
+      this.clearHeartbeatTimeout();
+      return;
+    }
+    try {
+      data = this.options.decode(raw);
+    } catch {
+      data = raw;
+    }
+    const message = {
+      type: event.data instanceof ArrayBuffer || event.data instanceof Blob ? "binary" : "text",
+      data,
+      raw,
+      timestamp: Date.now()
+    };
+    this.lastMessage.value = message;
+    this.onMessageCallback?.(message);
+  }
+  reconnect() {
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    const delay = Math.min(this.options.reconnectInterval * Math.pow(2, this.reconnectAttempts - 1), this.options.reconnectMaxDelay);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {});
+    }, delay);
+  }
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send("ping");
+        this.heartbeatTimeoutTimer = setTimeout(() => {
+          this.disconnect(4e3, "Heartbeat timeout");
+        }, this.options.heartbeatTimeout);
+      }
+    }, this.options.heartbeatInterval);
+  }
+  clearHeartbeatTimeout() {
+    if (this.heartbeatTimeoutTimer) {
+      clearTimeout(this.heartbeatTimeoutTimer);
+      this.heartbeatTimeoutTimer = null;
+    }
+  }
+  clearTimers() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.clearHeartbeatTimeout();
+  }
+  /**
+   * 清理资源
+   */
+  dispose() {
+    this.disconnect();
+    this.onOpenCallback = null;
+    this.onCloseCallback = null;
+    this.onErrorCallback = null;
+    this.onMessageCallback = null;
+    this.onStateChangeCallback = null;
+  }
+}
+exports.WebSocketClient = WebSocketClient;
+function useWebSocket(options) {
+  const client = new WebSocketClient(options);
+  const state = client.state;
+  const isConnected = client.isConnected;
+  const lastMessage = client.lastMessage;
+  (0, _vue.onUnmounted)(() => {
+    client.dispose();
+  });
+  return {
+    /** 当前状态 */
+    state,
+    /** 是否已连接 */
+    isConnected,
+    /** 最后收到的消息 */
+    lastMessage,
+    /** 连接 */
+    connect: () => client.connect(),
+    /** 断开连接 */
+    disconnect: (code, reason) => client.disconnect(code, reason),
+    /** 发送消息 */
+    send: data => client.send(data),
+    /** 发送并等待响应 */
+    sendAndWait: (data, timeout) => client.sendAndWait(data, timeout),
+    /** 事件监听 */
+    onOpen: callback => client.onOpen(callback),
+    onClose: callback => client.onClose(callback),
+    onError: callback => client.onError(callback),
+    onMessage: callback => client.onMessage(callback),
+    onStateChange: callback => client.onStateChange(callback),
+    /** 获取原始客户端 */
+    getClient: () => client
+  };
+}
+function createWebSocket(options) {
+  return new WebSocketClient(options);
+}
+function isWebSocketSupported() {
+  return typeof WebSocket !== "undefined";
+}