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

package/dist/base-tools-web.umd.global.js

@@ -47,6 +47,7 @@ var baseToolsWeb = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  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) => {
@@ -1771,6 +1772,262 @@ var baseToolsWeb = (() => {
     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) {
@@ -1792,18 +2049,16 @@ var baseToolsWeb = (() => {
       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);
@@ -1875,7 +2130,7 @@ var baseToolsWeb = (() => {
           }
           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;
@@ -1976,17 +2231,25 @@ var baseToolsWeb = (() => {
     }
     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 (sseTask.parser === void 0) {
+        throw new Error(
+          "Stream parser missing: Please set config.onMessage when enableChunked is true"
+        );
+      }
       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";
     });
   }