@base-web-kits/base-tools-web 1.3.3 → 1.3.5

package/dist/index.d.cts

@@ -323,6 +323,34 @@ declare function hasCss(href: string): boolean;
  */
 declare function preloadImage(src: string): Promise<HTMLImageElement>;
 
+/** 流式数据消息 */
+type SSEMessage = {
+    /**
+     * SSE 消息类型
+     * - 'DONE' 流式数据接收完毕
+     * - 'thinking' 思考中
+     * - 'text' 文本内容
+     * - 其他业务类型
+     */
+    type?: string;
+    /** SSE 事件 ID (如 'id:123') */
+    id?: string;
+    /** SSE 建议重连时间 (毫秒, 如 'retry:5000') */
+    retry?: number;
+    /** SSE 事件类型 (如 'event:customEvent') */
+    event?: string;
+    /**
+     * 除type之外的其他data数据
+     * - 思考中 'data:{"type": "thinking", "content": "xx"}' -> {type: 'thinking', content: 'xx'}
+     * - JSON数据 'data:{"type": "text", "content": "xx"}' -> {type: 'text', content: 'xx'}
+     * - 非JSON数据 'data:xx' -> {raw: 'xx'}
+     * - 接收完毕 'data:[DONE]' -> {type: 'DONE'}
+     */
+    [key: string]: any;
+};
+/** 流式数据消息回调 */
+type MessageCallback = (msg: SSEMessage) => void;
+
 /** 请求方法类型 */
 type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'PATCH';
 /**
@@ -380,23 +408,17 @@ type RequestConfigBase<D extends RequestData = RequestData> = {
     logExtra?: Record<string, unknown>;
     /** 响应数据的转换 */
     resMap?: (data: ResponseData) => ResponseData;
-    /** 获取task对象, 用于取消请求或监听流式数据 */
+    /** 获取请求对象, 用于取消请求 */
     onTaskReady?: (task: RequestTask) => void;
+    /** 流式数据接收事件回调 (已完成基础流式解析,返回消息对象) */
+    onMessage?: MessageCallback;
 };
-/**
- * 请求任务对象 (用于取消请求或监听流式数据)
- */
-interface RequestTask {
+/** 请求任务对象 (用于取消请求) */
+type RequestTask = {
     /** 取消请求 */
     abort: () => void;
-    /** 监听流式数据块接收事件 */
-    onChunkReceived: (callback: ChunkCallback) => void;
-    /** 取消监听流式数据块接收事件 */
-    offChunkReceived: () => void;
-}
-/**
- * 流式数据块接收事件回调
- */
+};
+/** 流式数据块接收事件回调 */
 type ChunkCallback = (response: {
     data: ArrayBuffer;
 }) => void;
@@ -462,20 +484,23 @@ type ChunkCallback = (response: {
  *   });
  * }
  *
- * // 流式监听
+ * // 初始化请求对象
+ * let chatTask: RequestTask;
  * const onTaskReady = (task: RequestTask) => {
- *    task.onChunkReceived((res) => {
- *      console.log('ArrayBuffer', res.data);
- *    });
+ *    chatTask = task;
+ * }
+ *
+ * // 流式监听
+ * const onMessage = (msg: SSEMessage) => {
+ *   console.log(msg);
  * }
  *
  * // 流式发起
  * const data = { content: '你好', chatId: 123 };
- * await apiChatStream({ data, onTaskReady });
+ * apiChatStream({ data, onTaskReady, onMessage });
  *
- * // 流式取消 (在组件销毁或页面关闭时调用)
- * task?.offChunkReceived(); // 取消监听,中断流式接收
- * task?.abort(); // 取消请求 (若流式已生成,此时abort无效,因为请求已成功)
+ * // 流式取消 (在组件销毁或页面关闭时调用, 若流式已生成, 此时abort无效, 因为请求已成功)
+ * chatTask?.abort();
  */
 declare function request<T, D extends RequestData = RequestData>(config: RequestConfigBase<D>): Promise<T>;
 /**

package/dist/index.mjs

@@ -17,6 +17,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -774,12 +775,12 @@ function isUnsafeProperty(key) {
 
 // src/ts/day/index.ts
 import dayjs from "dayjs";
-import customParseFormat from "dayjs/plugin/customParseFormat";
-import utc from "dayjs/plugin/utc";
-import timezone from "dayjs/plugin/timezone";
-import relativeTime from "dayjs/plugin/relativeTime";
-import advancedFormat from "dayjs/plugin/advancedFormat";
-import "dayjs/locale/zh-cn";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+import utc from "dayjs/plugin/utc.js";
+import timezone from "dayjs/plugin/timezone.js";
+import relativeTime from "dayjs/plugin/relativeTime.js";
+import advancedFormat from "dayjs/plugin/advancedFormat.js";
+import "dayjs/locale/zh-cn.js";
 dayjs.extend(customParseFormat);
 dayjs.extend(utc);
 dayjs.extend(timezone);
@@ -1010,6 +1011,262 @@ function appendUrlParam(url, param) {
   return base + (qs ? `?${qs}` : "") + hash;
 }
 
+// src/ts/buffer/PolyfillTextDecoder.ts
+var PolyfillTextDecoder = class {
+  constructor() {
+    __publicField(this, "leftOver", new Uint8Array(0));
+  }
+  decode(input, options) {
+    var _a;
+    const stream = (_a = options == null ? void 0 : options.stream) != null ? _a : false;
+    let bytes;
+    if (!input) {
+      bytes = new Uint8Array(0);
+    } else if (input instanceof ArrayBuffer) {
+      bytes = new Uint8Array(input);
+    } else {
+      bytes = input;
+    }
+    if (this.leftOver.length > 0) {
+      const merged = new Uint8Array(this.leftOver.length + bytes.length);
+      merged.set(this.leftOver);
+      merged.set(bytes, this.leftOver.length);
+      bytes = merged;
+      this.leftOver = new Uint8Array(0);
+    }
+    const len = bytes.length;
+    if (len === 0) return "";
+    const parts = [];
+    let i = 0;
+    const replacement = "\uFFFD";
+    const isContinuationByte = (b) => (b & 192) === 128;
+    while (i < len) {
+      const byte1 = bytes[i];
+      if (byte1 < 128) {
+        parts.push(String.fromCharCode(byte1));
+        i += 1;
+      } else if (byte1 >= 194 && byte1 < 224) {
+        if (i + 1 >= len) {
+          if (stream) {
+            this.leftOver = bytes.slice(i);
+            break;
+          }
+          parts.push(replacement);
+          break;
+        }
+        const byte2 = bytes[i + 1];
+        if (!isContinuationByte(byte2)) {
+          parts.push(replacement);
+          i += 1;
+          continue;
+        }
+        parts.push(String.fromCharCode((byte1 & 31) << 6 | byte2 & 63));
+        i += 2;
+      } else if (byte1 >= 224 && byte1 < 240) {
+        if (i + 2 >= len) {
+          if (stream) {
+            this.leftOver = bytes.slice(i);
+            break;
+          }
+          parts.push(replacement);
+          break;
+        }
+        const byte2 = bytes[i + 1];
+        const byte3 = bytes[i + 2];
+        if (!isContinuationByte(byte2) || !isContinuationByte(byte3)) {
+          parts.push(replacement);
+          i += 1;
+          continue;
+        }
+        if (byte1 === 224 && byte2 < 160) {
+          parts.push(replacement);
+          i += 3;
+          continue;
+        }
+        if (byte1 === 237 && byte2 >= 160) {
+          parts.push(replacement);
+          i += 3;
+          continue;
+        }
+        const codeUnit = (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
+        parts.push(String.fromCharCode(codeUnit));
+        i += 3;
+      } else if (byte1 >= 240 && byte1 <= 244) {
+        if (i + 3 >= len) {
+          if (stream) {
+            this.leftOver = bytes.slice(i);
+            break;
+          }
+          parts.push(replacement);
+          break;
+        }
+        const byte2 = bytes[i + 1];
+        const byte3 = bytes[i + 2];
+        const byte4 = bytes[i + 3];
+        if (!isContinuationByte(byte2) || !isContinuationByte(byte3) || !isContinuationByte(byte4)) {
+          parts.push(replacement);
+          i += 1;
+          continue;
+        }
+        if (byte1 === 240 && byte2 < 144) {
+          parts.push(replacement);
+          i += 4;
+          continue;
+        }
+        if (byte1 === 244 && byte2 >= 144) {
+          parts.push(replacement);
+          i += 4;
+          continue;
+        }
+        const codepoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+        const offset = codepoint - 65536;
+        parts.push(String.fromCharCode(55296 + (offset >> 10), 56320 + (offset & 1023)));
+        i += 4;
+      } else {
+        parts.push(replacement);
+        i += 1;
+      }
+    }
+    return parts.join("");
+  }
+};
+var PolyfillTextDecoder_default = PolyfillTextDecoder;
+
+// src/ts/buffer/SSEParser.ts
+var SSEParser = class {
+  constructor(onMessage) {
+    __publicField(this, "buffer", "");
+    __publicField(this, "onMessage");
+    __publicField(this, "decoder");
+    __publicField(this, "eventDataLines", []);
+    __publicField(this, "eventType");
+    __publicField(this, "eventId");
+    __publicField(this, "eventRetry");
+    this.onMessage = onMessage;
+    this.decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8") : new PolyfillTextDecoder_default();
+  }
+  /**
+   * 接收流式数据
+   * @param buffer ArrayBuffer
+   */
+  receive(buffer) {
+    const text = this.decoder.decode(new Uint8Array(buffer), { stream: true });
+    this.appendText(text);
+  }
+  /**
+   * 刷新解码器残留数据并处理尾部未换行的内容
+   */
+  flush() {
+    const tail = this.decoder.decode(void 0, { stream: false });
+    if (tail) this.appendText(tail);
+    this.flushRemainder();
+  }
+  /**
+   * 追加文本并按行拆分处理，保留不完整尾行
+   * @param text 新到达的文本片段
+   */
+  appendText(text) {
+    this.buffer += text;
+    const lines = this.buffer.split(/\r?\n/);
+    this.buffer = lines.pop() || "";
+    this.processLines(lines);
+  }
+  /**
+   * 处理缓冲区中剩余的尾行内容
+   */
+  flushRemainder() {
+    if (!this.buffer.trim()) {
+      this.buffer = "";
+      return;
+    }
+    const rest = this.buffer;
+    this.buffer = "";
+    this.processLines([rest, ""]);
+  }
+  /**
+   * 解析每行 SSE 数据并触发回调
+   * @param lines 以换行切分后的行内容
+   */
+  processLines(lines) {
+    for (const line of lines) {
+      if (!line.trim()) {
+        this.dispatchEvent();
+        continue;
+      }
+      if (line.startsWith(":")) continue;
+      const colonIndex = line.indexOf(":");
+      const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
+      let value = colonIndex === -1 ? "" : line.slice(colonIndex + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+      if (field === "data") {
+        this.eventDataLines.push(value);
+        continue;
+      }
+      if (field === "event") {
+        this.eventType = value || void 0;
+        continue;
+      }
+      if (field === "id") {
+        this.eventId = value || void 0;
+        continue;
+      }
+      if (field === "retry") {
+        const retry = Number(value);
+        this.eventRetry = Number.isFinite(retry) ? retry : void 0;
+        continue;
+      }
+    }
+  }
+  /**
+   * 将当前缓存的一次 SSE 事件分发给回调
+   * @description 以空行作为事件边界，将多行 data 合并后再解析；处理 "[DONE]" 结束标记；分发完成后会重置事件缓存
+   */
+  dispatchEvent() {
+    if (!this.eventDataLines.length) {
+      this.resetEvent();
+      return;
+    }
+    const data = this.eventDataLines.join("\n");
+    if (!data) {
+      this.resetEvent();
+      return;
+    }
+    if (data.trim() === "[DONE]") {
+      this.safeOnMessage({ type: "DONE" });
+      this.resetEvent();
+      return;
+    }
+    let msg;
+    try {
+      const json = JSON.parse(data);
+      msg = isPlainObject(json) ? json : { data: json };
+    } catch (e) {
+      msg = { raw: data };
+    }
+    if (this.eventType && msg.event === void 0) msg.event = this.eventType;
+    if (this.eventType && msg.type === void 0) msg.type = this.eventType;
+    if (this.eventId && msg.id === void 0) msg.id = this.eventId;
+    if (this.eventRetry !== void 0 && msg.retry === void 0) msg.retry = this.eventRetry;
+    this.safeOnMessage(msg);
+    this.resetEvent();
+  }
+  /** 安全调用 onMessage 回调，捕获并打印错误 */
+  safeOnMessage(msg) {
+    try {
+      this.onMessage(msg);
+    } catch (onMessageError) {
+      console.error("SSEParser onMessage error:", onMessageError);
+    }
+  }
+  /** 重置当前 SSE 事件的临时缓存 */
+  resetEvent() {
+    this.eventDataLines = [];
+    this.eventType = void 0;
+    this.eventId = void 0;
+    this.eventRetry = void 0;
+  }
+};
+
 // src/web/network/request.ts
 var requestCache = /* @__PURE__ */ new Map();
 function request(config) {
@@ -1031,18 +1288,16 @@ function request(config) {
     resMap,
     responseType = "json",
     timeout = 6e4,
-    onTaskReady
+    onTaskReady,
+    onMessage
   } = config;
   const controller = new AbortController();
   const signal = controller.signal;
-  let chunkCallback = null;
+  const sseTask = { parser: onMessage ? new SSEParser(onMessage) : void 0 };
   const task = {
-    abort: () => controller.abort(),
-    onChunkReceived: (cb) => {
-      chunkCallback = cb;
-    },
-    offChunkReceived: () => {
-      chunkCallback = null;
+    abort: () => {
+      sseTask.parser = null;
+      controller.abort();
     }
   };
   onTaskReady == null ? void 0 : onTaskReady(task);
@@ -1114,7 +1369,7 @@ function request(config) {
         }
         if (enableChunked) {
           if (showLoading) (_c = appConfig2.hideLoading) == null ? void 0 : _c.call(appConfig2);
-          const res2 = yield handleStreamResponse(response, chunkCallback);
+          const res2 = yield handleStreamResponse(response, sseTask);
           logRequestInfo({ status: "success", config: logConfig, startTime, res: res2 });
           resolve(res2);
           return;
@@ -1215,17 +1470,23 @@ function checkCache(cacheKey) {
   }
   return cached.res;
 }
-function handleStreamResponse(response, chunkCallback) {
+function handleStreamResponse(response, sseTask) {
   return __async(this, null, function* () {
-    if (!response.body) throw new Error("Response body is null");
+    if (!response.body) return "Stream is empty";
+    if (sseTask.parser === void 0) {
+      return "onMessage is undefined \u2192 Stream parser skipped";
+    }
     const reader = response.body.getReader();
     while (true) {
       const { done, value } = yield reader.read();
-      if (done) break;
-      if (chunkCallback && value) {
-        chunkCallback({ data: value.buffer });
+      if (sseTask.parser === null) {
+        yield reader.cancel();
+        throw new DOMException("BodyStreamBuffer was aborted", "AbortError");
       }
+      if (done) break;
+      if (sseTask.parser && value) sseTask.parser.receive(value.buffer);
     }
+    if (sseTask.parser) sseTask.parser.flush();
     return "Stream Finished";
   });
 }