@czf0613/http_client 0.1.1 → 0.1.2

package/README.md

@@ -2,6 +2,8 @@
 
 A simple HTTP client library built with fetch API, supporting a modified SSE (Server-Sent Events) protocol for browser environments.
 
+No any dependencies, it is very lightweight.
+
 ## Requirements
 
 - **Runtime**: ES2018+ compatible browsers
@@ -70,9 +72,34 @@ Makes an HTTP request with default configuration using the Fetch API.
   - FormData: sent as `multipart/form-data`
 - `timeoutMs` (number): Timeout in milliseconds. Default: 5000. **Note: this value is the *connect timeout*, not the total request timeout. You need to handle the *read timeout* in your application logic.**
 
-**Returns:** Promise<ExtendedResponse> - Extended Response object with additional helper methods. It's the same as the standard Response object, but with additional methods for convenience.
+**Returns:** `Promise<ExtendedResponse>` - Extended Response object with additional helper methods. It's the same as the standard Response object, but with additional methods for convenience.
+
+#### ExtendedResponse Methods
+
+In addition to all standard Response methods (`json()`, `text()`, `arrayBuffer()`, `blob()`, `bytes()`), ExtendedResponse provides the following timeout-enabled methods:
+
+**`jsonWithTimeout<T>(readTimeoutMs?: number): Promise<T>`**
+Reads the response body as JSON with a configurable timeout. Default timeout is 5000ms.
+- Throws `Error` with message `"JSON read timeout after Xms"` if timeout occurs
+- Throws parsing errors if JSON is invalid
+
+**`textWithTimeout(readTimeoutMs?: number): Promise<string>`**
+Reads the response body as text with a configurable timeout. Default timeout is 5000ms.
+- Throws `Error` with message `"Text read timeout after Xms"` if timeout occurs
+
+**`arrayBufferWithTimeout(readTimeoutMs?: number): Promise<ArrayBuffer>`**
+Reads the response body as ArrayBuffer with a configurable timeout. Default timeout is 5000ms.
+- Throws `Error` with message `"ArrayBuffer read timeout after Xms"` if timeout occurs
+
+**`blobWithTimeout(readTimeoutMs?: number): Promise<Blob>`**
+Reads the response body as Blob with a configurable timeout. Default timeout is 5000ms.
+- Throws `Error` with message `"Blob read timeout after Xms"` if timeout occurs
+
+**`bytesWithTimeout(readTimeoutMs?: number): Promise<Uint8Array<ArrayBuffer>>`**
+Reads the response body as Uint8Array with a configurable timeout. Default timeout is 5000ms.
+- Throws `Error` with message `"Bytes read timeout after Xms"` if timeout occurs
 
-**Note:** This function does not handle exceptions by default. You should wrap it in a try-catch block.
+**Note:** This function(including methods in `ExtendedResponse`) does not handle exceptions by default. You should wrap it in a try-catch block or using a promise chain.
 
 **Example:**
 
@@ -135,7 +162,7 @@ Makes an SSE (Server-Sent Events) request and returns an async generator that yi
 
 This method will **not** throw exceptions, you can get the success/failure status from the generator's return value.
 
-**Returns:** AsyncGenerator<string, boolean, undefined> - An async generator that yields each message as a string, and returns a boolean indicating success (true) or failure (false)
+**Returns:** `AsyncGenerator<string, boolean, undefined>` - An async generator that yields each message as a string, and returns a boolean indicating success (true) or failure (false)
 
 **Example:**
 

package/dist/http_client.js

@@ -1,5 +1,6 @@
 import { sleep, TIMEOUT_MARKER, DEFAULT_TIMEOUT } from './timer';
 import { ExtendedResponse } from './response_ext';
+import { extractSSELine } from './parser';
 /**
  * 拼接URL和查询参数，会自动处理转义
  * @param url 基础URL，不要带任何查询参数
@@ -164,32 +165,3 @@ export async function* makeSSERequest(url, method = 'GET', queryParams = null, c
     }
     return true;
 }
-/**
- * 解析SSE响应中的一行数据
- * @param buffer 需要处理的数组（只读，该函数不会修改它）
- * @returns 返回解析到的一行数据的结束索引，如果没有完整的一行数据，返回null。这个值指向最后一个\n的位置，slice的时候注意坐标运算
- */
-function extractSSELine(buffer) {
-    if (buffer.length < 8) {
-        // 每行数据至少都有'data: \n\n'，不够8个字节一定是不完整的
-        return null;
-    }
-    // 判断开头的6个字节是否是'data: '
-    if (buffer[0] !== 0x64 ||
-        buffer[1] !== 0x61 ||
-        buffer[2] !== 0x74 ||
-        buffer[3] !== 0x61 ||
-        buffer[4] !== 0x3A ||
-        buffer[5] !== 0x20) {
-        // 不是的话就有问题了
-        throw new Error('SSE data is not valid');
-    }
-    // 查找\n\n的位置
-    for (let i = 0; i < buffer.length - 1; ++i) {
-        if (buffer[i] === 0x0A && buffer[i + 1] === 0x0A) {
-            return i + 1;
-        }
-    }
-    // 没有找到\n\n，返回null
-    return null;
-}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { joinUrlWithParams, makeHttpRequest, makeSSERequest } from './http_client';
+export { type ExtendedResponse } from './response_ext';

package/dist/parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 解析SSE响应中的一行数据
+ * @param buffer 需要处理的数组（只读，该函数不会修改它）
+ * @returns 返回解析到的一行数据的结束索引，如果没有完整的一行数据，返回null。这个值指向最后一个\n的位置，slice的时候注意坐标运算
+ */
+export declare function extractSSELine(buffer: Uint8Array): number | null;

package/dist/parser.js

@@ -0,0 +1,29 @@
+/**
+ * 解析SSE响应中的一行数据
+ * @param buffer 需要处理的数组（只读，该函数不会修改它）
+ * @returns 返回解析到的一行数据的结束索引，如果没有完整的一行数据，返回null。这个值指向最后一个\n的位置，slice的时候注意坐标运算
+ */
+export function extractSSELine(buffer) {
+    if (buffer.length < 8) {
+        // 每行数据至少都有'data: \n\n'，不够8个字节一定是不完整的
+        return null;
+    }
+    // 判断开头的6个字节是否是'data: '
+    if (buffer[0] !== 0x64 ||
+        buffer[1] !== 0x61 ||
+        buffer[2] !== 0x74 ||
+        buffer[3] !== 0x61 ||
+        buffer[4] !== 0x3A ||
+        buffer[5] !== 0x20) {
+        // 不是的话就有问题了
+        throw new Error('SSE data is not valid');
+    }
+    // 查找\n\n的位置
+    for (let i = 0; i < buffer.length - 1; ++i) {
+        if (buffer[i] === 0x0A && buffer[i + 1] === 0x0A) {
+            return i + 1;
+        }
+    }
+    // 没有找到\n\n，返回null
+    return null;
+}

package/dist/response_ext.d.ts

@@ -8,6 +8,41 @@ export declare class ExtendedResponse implements Response {
     get [Symbol.toStringTag](): string;
     static create(response: Response): ExtendedResponse;
     clone(): ExtendedResponse;
+    /**
+     * 从响应体中读取JSON数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的JSON数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    jsonWithTimeout<T>(readTimeoutMs?: number): Promise<T>;
+    /**
+     * 从响应体中读取文本数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的文本数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    textWithTimeout(readTimeoutMs?: number): Promise<string>;
+    /**
+     * 从响应体中读取数组缓冲区数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的数组缓冲区数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    arrayBufferWithTimeout(readTimeoutMs?: number): Promise<ArrayBuffer>;
+    /**
+     * 从响应体中读取Blob数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的Blob数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    blobWithTimeout(readTimeoutMs?: number): Promise<Blob>;
+    /**
+     * 从响应体中读取字节数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的字节数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    bytesWithTimeout(readTimeoutMs?: number): Promise<Uint8Array<ArrayBuffer>>;
     readonly body: ReadableStream<Uint8Array<ArrayBuffer>> | null;
     readonly bodyUsed: boolean;
     readonly headers: Headers;

package/dist/response_ext.js

@@ -1,3 +1,4 @@
+import { sleep, TIMEOUT_MARKER, DEFAULT_TIMEOUT } from "./timer";
 /**
  * 扩展的Response类，使用Proxy自动代理所有Response属性和方法
  * 用户可以像普通的Response对象一样使用，也可以调用额外的方法
@@ -22,6 +23,11 @@ export class ExtendedResponse {
                     case '_response':
                     case 'create':
                     case 'clone':
+                    case 'jsonWithTimeout':
+                    case 'textWithTimeout':
+                    case 'arrayBufferWithTimeout':
+                    case 'blobWithTimeout':
+                    case 'bytesWithTimeout':
                         return target[prop];
                     default:
                         // 否则从原始Response获取
@@ -36,6 +42,92 @@ export class ExtendedResponse {
     clone() {
         return ExtendedResponse.create(this._response.clone());
     }
+    // 以下是一些额外的方法
+    /**
+     * 从响应体中读取JSON数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的JSON数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    async jsonWithTimeout(readTimeoutMs = DEFAULT_TIMEOUT) {
+        const raceResult = await Promise.race([
+            sleep(readTimeoutMs),
+            this._response.json(),
+        ]);
+        // 如果timeout先完成，说明超时了
+        if (raceResult === TIMEOUT_MARKER) {
+            throw new Error(`JSON read timeout after ${readTimeoutMs}ms`);
+        }
+        return raceResult;
+    }
+    /**
+     * 从响应体中读取文本数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的文本数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    async textWithTimeout(readTimeoutMs = DEFAULT_TIMEOUT) {
+        const raceResult = await Promise.race([
+            sleep(readTimeoutMs),
+            this._response.text(),
+        ]);
+        // 如果timeout先完成，说明超时了
+        if (raceResult === TIMEOUT_MARKER) {
+            throw new Error(`Text read timeout after ${readTimeoutMs}ms`);
+        }
+        return raceResult;
+    }
+    /**
+     * 从响应体中读取数组缓冲区数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的数组缓冲区数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    async arrayBufferWithTimeout(readTimeoutMs = DEFAULT_TIMEOUT) {
+        const raceResult = await Promise.race([
+            sleep(readTimeoutMs),
+            this._response.arrayBuffer(),
+        ]);
+        // 如果timeout先完成，说明超时了
+        if (raceResult === TIMEOUT_MARKER) {
+            throw new Error(`ArrayBuffer read timeout after ${readTimeoutMs}ms`);
+        }
+        return raceResult;
+    }
+    /**
+     * 从响应体中读取Blob数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的Blob数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    async blobWithTimeout(readTimeoutMs = DEFAULT_TIMEOUT) {
+        const raceResult = await Promise.race([
+            sleep(readTimeoutMs),
+            this._response.blob(),
+        ]);
+        // 如果timeout先完成，说明超时了
+        if (raceResult === TIMEOUT_MARKER) {
+            throw new Error(`Blob read timeout after ${readTimeoutMs}ms`);
+        }
+        return raceResult;
+    }
+    /**
+     * 从响应体中读取字节数据，支持超时设置
+     * @param readTimeoutMs 读取请求体的超时时间，单位毫秒
+     * @returns 解析后的字节数据
+     * @throws 如果读取超时或解析失败，会抛出错误
+     */
+    async bytesWithTimeout(readTimeoutMs = DEFAULT_TIMEOUT) {
+        const raceResult = await Promise.race([
+            sleep(readTimeoutMs),
+            this._response.bytes(),
+        ]);
+        // 如果timeout先完成，说明超时了
+        if (raceResult === TIMEOUT_MARKER) {
+            throw new Error(`Bytes read timeout after ${readTimeoutMs}ms`);
+        }
+        return raceResult;
+    }
     // Response接口的方法（实际通过Proxy代理到原始Response，这里的方法都也是骗编译器的）
     arrayBuffer() {
         throw new Error('Method not implemented.');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@czf0613/http_client",
   "private": false,
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Simple http client with fetch, supporting modified SSE protocol",
   "keywords": [
     "http client",
@@ -20,8 +20,9 @@
   },
   "scripts": {
     "build": "tsc",
+    "prepack": "npm run build",
     "pretest": "npm run build",
-    "test": "npx tsx tests/test_bing.ts"
+    "test": "npx tsx tests/run_all.ts"
   },
   "repository": {
     "type": "git",