@ahoo-wang/fetcher-eventstream 2.9.6 → 2.9.8

package/README.md

@@ -24,6 +24,7 @@ APIs.
 - **🛡️ TypeScript Support**: Complete TypeScript type definitions
 - **⚡ Performance Optimized**: Efficient parsing and streaming for high-performance applications
 - **🤖 LLM Streaming Ready**: Native support for streaming responses from popular LLM APIs like OpenAI GPT, Claude, etc.
+- **🔚 Stream Termination**: Automatic stream termination detection for clean resource management and completion handling
 
 ## 🚀 Quick Start
 
@@ -245,6 +246,47 @@ for await (const event of response.requiredJsonEventStream<MyDataType>()) {
 }
 ```
 
+### Advanced Usage with Termination Detection
+
+```typescript
+import { Fetcher } from '@ahoo-wang/fetcher';
+import {
+  toJsonServerSentEventStream,
+  type TerminateDetector,
+} from '@ahoo-wang/fetcher-eventstream';
+
+const fetcher = new Fetcher({
+  baseURL: 'https://api.openai.com/v1',
+});
+
+// Define termination detector for OpenAI-style completion
+const terminateOnDone: TerminateDetector = event => event.data === '[DONE]';
+
+// Get raw event stream
+const response = await fetcher.post('/chat/completions', {
+  body: {
+    model: 'gpt-3.5-turbo',
+    messages: [{ role: 'user', content: 'Hello!' }],
+    stream: true,
+  },
+});
+
+// Convert to typed JSON stream with automatic termination
+const jsonStream = toJsonServerSentEventStream<ChatCompletionChunk>(
+  response.requiredEventStream(),
+  terminateOnDone,
+);
+
+// Process streaming response with automatic termination
+for await (const event of jsonStream) {
+  const content = event.data.choices[0]?.delta?.content;
+  if (content) {
+    console.log('Token:', content);
+    // Stream automatically terminates when '[DONE]' is received
+  }
+}
+```
+
 ### Manual Conversion
 
 ```typescript
@@ -310,24 +352,49 @@ for await (const event of response.requiredEventStream()) {
 ### toJsonServerSentEventStream
 
 Converts a `ServerSentEventStream` to a `JsonServerSentEventStream<DATA>` for handling Server-Sent Events with JSON
-data.
+data. Optionally supports stream termination detection for automatic stream closure.
 
 #### Signature
 
 ```typescript
 function toJsonServerSentEventStream<DATA>(
   serverSentEventStream: ServerSentEventStream,
+  terminateDetector?: TerminateDetector,
 ): JsonServerSentEventStream<DATA>;
 ```
 
 #### Parameters
 
 - `serverSentEventStream`: The `ServerSentEventStream` to convert
+- `terminateDetector`: Optional function to detect when the stream should be terminated. When provided, the stream will automatically close when the detector returns `true` for an event.
 
 #### Returns
 
 - `JsonServerSentEventStream<DATA>`: A readable stream of `JsonServerSentEvent<DATA>` objects
 
+#### Examples
+
+```typescript
+// Basic usage without termination detection
+const jsonStream = toJsonServerSentEventStream<MyData>(serverSentEventStream);
+
+// With termination detection for OpenAI-style completion
+const terminateOnDone: TerminateDetector = event => event.data === '[DONE]';
+const terminatingStream = toJsonServerSentEventStream<MyData>(
+  serverSentEventStream,
+  terminateOnDone,
+);
+
+// Custom termination logic
+const terminateOnError: TerminateDetector = event => {
+  return event.event === 'error' || event.data.includes('ERROR');
+};
+const errorHandlingStream = toJsonServerSentEventStream<MyData>(
+  serverSentEventStream,
+  terminateOnError,
+);
+```
+
 ### JsonServerSentEvent
 
 Interface defining the structure of a Server-Sent Event with JSON data.
@@ -348,6 +415,57 @@ type JsonServerSentEventStream<DATA> = ReadableStream<
 >;
 ```
 
+### TerminateDetector
+
+A function type for detecting when a Server-Sent Event stream should be terminated. This is commonly used with LLM APIs that send a special termination event to signal the end of a response stream.
+
+#### Signature
+
+```typescript
+type TerminateDetector = (event: ServerSentEvent) => boolean;
+```
+
+#### Parameters
+
+- `event`: The current `ServerSentEvent` being processed
+
+#### Returns
+
+- `boolean`: `true` if the stream should be terminated, `false` otherwise
+
+#### Examples
+
+```typescript
+// OpenAI-style termination (common pattern)
+const terminateOnDone: TerminateDetector = event => event.data === '[DONE]';
+
+// Event-based termination
+const terminateOnComplete: TerminateDetector = event => event.event === 'done';
+
+// Custom termination with multiple conditions
+const terminateOnFinish: TerminateDetector = event => {
+  return (
+    event.event === 'done' ||
+    event.event === 'error' ||
+    event.data === '[DONE]' ||
+    event.data.includes('TERMINATE')
+  );
+};
+
+// Usage with toJsonServerSentEventStream
+const stream = toJsonServerSentEventStream<MyData>(
+  serverSentEventStream,
+  terminateOnDone,
+);
+```
+
+#### Common Use Cases
+
+- **LLM Streaming**: Detect completion markers like `[DONE]` from OpenAI, Claude, or other LLM APIs
+- **Error Handling**: Terminate streams when error events are received
+- **Custom Protocols**: Implement application-specific termination logic
+- **Resource Management**: Automatically close streams when certain conditions are met
+
 ### toServerSentEventStream
 
 Converts a `Response` object with a `text/event-stream` body to a `ServerSentEventStream`.

package/README.zh-CN.md

@@ -20,6 +20,7 @@
 - **🛡️ TypeScript 支持**：完整的 TypeScript 类型定义
 - **⚡ 性能优化**：高效的解析和流处理，适用于高性能应用
 - **🤖 LLM 流准备就绪**: 原生支持来自流行 LLM API（如 OpenAI GPT、Claude 等）的流式响应
+- **🔚 流终止检测**：自动流终止检测，实现干净的资源管理和完成处理
 
 ## 🚀 快速开始
 
@@ -216,6 +217,47 @@ for await (const event of response.requiredJsonEventStream<MyDataType>()) {
 }
 ```
 
+### 高级用法与终止检测
+
+```typescript
+import { Fetcher } from '@ahoo-wang/fetcher';
+import {
+  toJsonServerSentEventStream,
+  type TerminateDetector,
+} from '@ahoo-wang/fetcher-eventstream';
+
+const fetcher = new Fetcher({
+  baseURL: 'https://api.openai.com/v1',
+});
+
+// 定义 OpenAI 风格完成的终止检测器
+const terminateOnDone: TerminateDetector = event => event.data === '[DONE]';
+
+// 获取原始事件流
+const response = await fetcher.post('/chat/completions', {
+  body: {
+    model: 'gpt-3.5-turbo',
+    messages: [{ role: 'user', content: '你好！' }],
+    stream: true,
+  },
+});
+
+// 转换为带自动终止的类型化 JSON 流
+const jsonStream = toJsonServerSentEventStream<ChatCompletionChunk>(
+  response.requiredEventStream(),
+  terminateOnDone,
+);
+
+// 处理带自动终止的流式响应
+for await (const event of jsonStream) {
+  const content = event.data.choices[0]?.delta?.content;
+  if (content) {
+    console.log('令牌:', content);
+    // 当收到 '[DONE]' 时流会自动终止
+  }
+}
+```
+
 ### 手动转换
 
 ```typescript
@@ -278,24 +320,49 @@ for await (const event of response.requiredEventStream()) {
 
 ### toJsonServerSentEventStream
 
-将 `ServerSentEventStream` 转换为 `JsonServerSentEventStream<DATA>`，用于处理带有 JSON 数据的服务器发送事件。
+将 `ServerSentEventStream` 转换为 `JsonServerSentEventStream<DATA>`，用于处理带有 JSON 数据的服务器发送事件。可选支持流终止检测以实现自动流关闭。
 
 #### 签名
 
 ```typescript
 function toJsonServerSentEventStream<DATA>(
   serverSentEventStream: ServerSentEventStream,
+  terminateDetector?: TerminateDetector,
 ): JsonServerSentEventStream<DATA>;
 ```
 
 #### 参数
 
 - `serverSentEventStream`：要转换的 ServerSentEventStream
+- `terminateDetector`：可选的函数，用于检测何时应该终止流。当提供时，当检测器对某个事件返回 `true` 时，流将自动关闭。
 
 #### 返回
 
 - `JsonServerSentEventStream<DATA>`：带有 JSON 数据的 ServerSentEvent 对象的可读流
 
+#### 示例
+
+```typescript
+// 基本用法，不使用终止检测
+const jsonStream = toJsonServerSentEventStream<MyData>(serverSentEventStream);
+
+// 使用终止检测处理 OpenAI 风格的完成
+const terminateOnDone: TerminateDetector = event => event.data === '[DONE]';
+const terminatingStream = toJsonServerSentEventStream<MyData>(
+  serverSentEventStream,
+  terminateOnDone,
+);
+
+// 自定义终止逻辑
+const terminateOnError: TerminateDetector = event => {
+  return event.event === 'error' || event.data.includes('ERROR');
+};
+const errorHandlingStream = toJsonServerSentEventStream<MyData>(
+  serverSentEventStream,
+  terminateOnError,
+);
+```
+
 ### JsonServerSentEvent
 
 定义带有 JSON 数据的服务器发送事件结构的接口。
@@ -316,6 +383,57 @@ type JsonServerSentEventStream<DATA> = ReadableStream<
 >;
 ```
 
+### TerminateDetector
+
+用于检测服务器发送事件流何时应该终止的函数类型。这通常用于 LLM API 发送特殊终止事件来表示响应流结束的情况。
+
+#### 签名
+
+```typescript
+type TerminateDetector = (event: ServerSentEvent) => boolean;
+```
+
+#### 参数
+
+- `event`：当前正在处理的 `ServerSentEvent`
+
+#### 返回
+
+- `boolean`：如果应该终止流则返回 `true`，否则返回 `false`
+
+#### 示例
+
+```typescript
+// OpenAI 风格的终止（常见模式）
+const terminateOnDone: TerminateDetector = event => event.data === '[DONE]';
+
+// 基于事件的终止
+const terminateOnComplete: TerminateDetector = event => event.event === 'done';
+
+// 具有多个条件的自定义终止
+const terminateOnFinish: TerminateDetector = event => {
+  return (
+    event.event === 'done' ||
+    event.event === 'error' ||
+    event.data === '[DONE]' ||
+    event.data.includes('TERMINATE')
+  );
+};
+
+// 与 toJsonServerSentEventStream 一起使用
+const stream = toJsonServerSentEventStream<MyData>(
+  serverSentEventStream,
+  terminateOnDone,
+);
+```
+
+#### 常见用例
+
+- **LLM 流式传输**：检测来自 OpenAI、Claude 或其他 LLM API 的完成标记，如 `[DONE]`
+- **错误处理**：在收到错误事件时终止流
+- **自定义协议**：实现应用程序特定的终止逻辑
+- **资源管理**：在满足特定条件时自动关闭流
+
 ### toServerSentEventStream
 
 将带有 `text/event-stream` 主体的 Response 对象转换为 ServerSentEvent 对象的可读流。

package/dist/eventStreamConverter.d.ts

@@ -2,33 +2,99 @@ import { ServerSentEvent } from './serverSentEventTransformStream';
 import { FetcherError } from '@ahoo-wang/fetcher';
 /**
  * A ReadableStream of ServerSentEvent objects.
+ *
+ * This type represents a stream that yields Server-Sent Event objects as they are parsed
+ * from a raw event stream. Each chunk in the stream contains a complete SSE event with
+ * its metadata (event type, ID, retry interval) and data.
+ *
+ * @see {@link ServerSentEvent} for the structure of individual events
+ * @see {@link toServerSentEventStream} for converting HTTP responses to this type
  */
 export type ServerSentEventStream = ReadableStream<ServerSentEvent>;
 /**
  * Custom error class for event stream conversion errors.
- * Thrown when there are issues converting a Response to a ServerSentEventStream.
+ *
+ * This error is thrown when there are issues converting an HTTP Response to a ServerSentEventStream.
+ * It extends FetcherError to provide additional context about the failed conversion, including
+ * the original Response object and any underlying cause.
+ *
+ * @extends {FetcherError}
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const eventStream = toServerSentEventStream(response);
+ * } catch (error) {
+ *   if (error instanceof EventStreamConvertError) {
+ *     console.error('Failed to convert response to event stream:', error.message);
+ *     console.log('Response status:', error.response.status);
+ *   }
+ * }
+ * ```
  */
 export declare class EventStreamConvertError extends FetcherError {
     readonly response: Response;
     /**
      * Creates a new EventStreamConvertError instance.
-     * @param response - The Response object associated with the error
+     *
+     * @param response - The Response object associated with the error, providing context
+     *                   about the failed conversion (status, headers, etc.)
      * @param errorMsg - Optional error message describing what went wrong during conversion
-     * @param cause - Optional underlying error that caused this error
+     * @param cause - Optional underlying error that caused this conversion error
      */
     constructor(response: Response, errorMsg?: string, cause?: Error | any);
 }
 /**
  * Converts a Response object to a ServerSentEventStream.
  *
- * Processes the response body through a series of transform streams:
- * 1. TextDecoderStream: Decode Uint8Array data to UTF-8 strings
- * 2. TextLineStream: Split text by lines
- * 3. ServerSentEventStream: Parse line data into server-sent events
+ * This function takes an HTTP Response object and converts its body into a stream of
+ * Server-Sent Event objects. The conversion process involves several transformation steps:
+ *
+ * 1. **TextDecoderStream**: Decodes the raw Uint8Array response body to UTF-8 strings
+ * 2. **TextLineTransformStream**: Splits the text stream into individual lines
+ * 3. **ServerSentEventTransformStream**: Parses the line-based SSE format into structured events
+ *
+ * The resulting stream can be consumed using async iteration or other stream methods.
+ *
+ * @param response - The HTTP Response object to convert. Must have a readable body stream.
+ * @returns A ReadableStream that yields ServerSentEvent objects as they are parsed from the response
+ * @throws {EventStreamConvertError} If the response body is null or cannot be processed
+ *
+ * @example
+ * ```typescript
+ * // Convert an SSE response to an event stream
+ * const response = await fetch('/api/events');
+ * const eventStream = toServerSentEventStream(response);
+ *
+ * // Consume events asynchronously
+ * for await (const event of eventStream) {
+ *   console.log(`Event: ${event.event}, Data: ${event.data}`);
+ *
+ *   // Handle different event types
+ *   switch (event.event) {
+ *     case 'message':
+ *       handleMessage(event.data);
+ *       break;
+ *     case 'error':
+ *       handleError(event.data);
+ *       break;
+ *   }
+ * }
+ * ```
  *
- * @param response - The Response object to convert
- * @returns A ReadableStream of ServerSentEvent objects
- * @throws Error if the response body is null
+ * @example
+ * ```typescript
+ * // Handle conversion errors
+ * try {
+ *   const eventStream = toServerSentEventStream(response);
+ *   // Use the stream...
+ * } catch (error) {
+ *   if (error instanceof EventStreamConvertError) {
+ *     console.error('Event stream conversion failed:', error.message);
+ *     console.log('Response status:', error.response.status);
+ *   }
+ * }
+ * ```
  */
 export declare function toServerSentEventStream(response: Response): ServerSentEventStream;
 //# sourceMappingURL=eventStreamConverter.d.ts.map

package/dist/eventStreamConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eventStreamConverter.d.ts","sourceRoot":"","sources":["../src/eventStreamConverter.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,eAAe,CAAC,CAAC;AAEpE;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;aAQrC,QAAQ,EAAE,QAAQ;IAPpC;;;;;OAKG;gBAEe,QAAQ,EAAE,QAAQ,EAClC,QAAQ,CAAC,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,KAAK,GAAG,GAAG;CAOtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,GACjB,qBAAqB,CASvB"}
+{"version":3,"file":"eventStreamConverter.d.ts","sourceRoot":"","sources":["../src/eventStreamConverter.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,eAAe,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;aAUrC,QAAQ,EAAE,QAAQ;IATpC;;;;;;;OAOG;gBAEe,QAAQ,EAAE,QAAQ,EAClC,QAAQ,CAAC,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,KAAK,GAAG,GAAG;CAOtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,GACjB,qBAAqB,CASvB"}

package/dist/eventStreamResultExtractor.d.ts

@@ -2,19 +2,46 @@ import { ResultExtractor } from '@ahoo-wang/fetcher';
 import { ServerSentEventStream } from './eventStreamConverter';
 import { JsonServerSentEventStream } from './jsonServerSentEventTransformStream';
 /**
- * ServerSentEventStream result extractor, used to extract server-sent event stream from FetchExchange
+ * ServerSentEventStream result extractor for Fetcher HTTP client.
  *
- * @param exchange - FetchExchange object containing request and response information
- * @returns Readable stream object of server-sent event stream
- * @throws ExchangeError exception when server does not support ServerSentEventStream
+ * This result extractor is designed to work with the Fetcher HTTP client library.
+ * It extracts a ServerSentEventStream from an HTTP response that contains Server-Sent Events.
+ * The extractor validates that the response supports event streaming and converts the
+ * response body into a properly typed event stream.
+ *
+ * This extractor should be used when you want to consume raw Server-Sent Events
+ * without JSON parsing, maintaining the original string data format.
+ *
+ * @param exchange - The FetchExchange object containing request and response information
+ * @returns A ReadableStream that yields ServerSentEvent objects as they are parsed from the response
+ * @throws {ExchangeError} When the server response does not support ServerSentEventStream
+ *                         (e.g., wrong content type, no response body)
+ *
+ *
+ * @see {@link ServerSentEventStream} for the stream type
+ * @see {@link JsonEventStreamResultExtractor} for JSON-parsed event streams
  */
 export declare const EventStreamResultExtractor: ResultExtractor<ServerSentEventStream>;
 /**
- * JsonServerSentEventStream result extractor, used to extract JSON server-sent event stream from FetchExchange
+ * JsonServerSentEventStream result extractor for Fetcher HTTP client.
+ *
+ * This result extractor is designed to work with the Fetcher HTTP client library.
+ * It extracts a JsonServerSentEventStream from an HTTP response that contains Server-Sent Events
+ * with JSON data. The extractor validates that the response supports event streaming and converts
+ * the response body into a properly typed event stream with automatic JSON parsing.
+ *
+ * This extractor should be used when you want to consume Server-Sent Events where the event
+ * data is JSON-formatted, providing type-safe access to parsed JSON objects instead of raw strings.
+ *
+ * @template DATA - The expected type of the JSON data in the server-sent events
+ * @param exchange - The FetchExchange object containing request and response information
+ * @returns A ReadableStream that yields ServerSentEvent objects with parsed JSON data as they are received
+ * @throws {ExchangeError} When the server response does not support JsonServerSentEventStream
+ *                         (e.g., wrong content type, no response body, invalid JSON)
+ *
  *
- * @param exchange - FetchExchange object containing request and response information
- * @returns Readable stream object of JSON server-sent event stream
- * @throws ExchangeError exception when server does not support JsonServerSentEventStream
+ * @see {@link JsonServerSentEventStream} for the stream type with JSON data
+ * @see {@link EventStreamResultExtractor} for raw string event streams
  */
 export declare const JsonEventStreamResultExtractor: ResultExtractor<JsonServerSentEventStream<any>>;
 //# sourceMappingURL=eventStreamResultExtractor.d.ts.map

package/dist/eventStreamResultExtractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eventStreamResultExtractor.d.ts","sourceRoot":"","sources":["../src/eventStreamResultExtractor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAiB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEjF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,eAAe,CACtD,qBAAqB,CAGtB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,EAAE,eAAe,CAC1D,yBAAyB,CAAC,GAAG,CAAC,CAG/B,CAAC"}
+{"version":3,"file":"eventStreamResultExtractor.d.ts","sourceRoot":"","sources":["../src/eventStreamResultExtractor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAiB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,0BAA0B,EAAE,eAAe,CACtD,qBAAqB,CAGtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,8BAA8B,EAAE,eAAe,CAC1D,yBAAyB,CAAC,GAAG,CAAC,CAG/B,CAAC"}

package/dist/index.d.ts

@@ -1,3 +1,51 @@
+/**
+ * @packageDocumentation
+ * @module @ahoo-wang/fetcher-eventstream
+ *
+ * # EventStream Package
+ *
+ * A comprehensive TypeScript library for handling Server-Sent Events (SSE) and stream processing.
+ * This package provides utilities for converting, transforming, and consuming event streams with
+ * full TypeScript support and async iteration capabilities.
+ *
+ * ## Key Features
+ *
+ * - **Server-Sent Event Processing**: Parse and transform SSE streams into typed objects
+ * - **JSON Event Streams**: Convert raw SSE to typed JSON event streams with optional termination detection
+ * - **Stream Utilities**: Async iteration support for ReadableStreams
+ * - **HTTP Response Handling**: Specialized extractors for event stream responses
+ * - **Type Safety**: Full TypeScript support with generic types and strict typing
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import {
+ *   toJsonServerSentEventStream,
+ *   type TerminateDetector
+ * } from '@ahoo-wang/fetcher-eventstream';
+ *
+ * // Convert a Server-Sent Event stream to typed JSON events
+ * const terminateOnDone: TerminateDetector = (event) => event.data === '[DONE]';
+ * const jsonStream = toJsonServerSentEventStream<MyData>(sseStream, terminateOnDone);
+ *
+ * // Consume the stream
+ * for await (const event of jsonStream) {
+ *   console.log('Received:', event.data);
+ * }
+ * ```
+ *
+ * ## Main Components
+ *
+ * - `toJsonServerSentEventStream()` - Convert SSE streams to typed JSON streams
+ * - `JsonServerSentEventTransformStream` - Transform stream class with termination support
+ * - `ServerSentEventStream` - Raw server-sent event stream type
+ * - `ReadableStreamAsyncIterable` - Async iteration utilities for streams
+ * - `EventStreamResultExtractor` - HTTP response extractor for event streams
+ *
+ * @see {@link toJsonServerSentEventStream} for the main conversion function
+ * @see {@link JsonServerSentEventTransformStream} for stream transformation
+ * @see {@link TerminateDetector} for termination detection
+ */
 export * from './eventStreamConverter';
 export * from './jsonServerSentEventTransformStream';
 export * from './eventStreamResultExtractor';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sCAAsC,CAAC;AACrD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC;AAC5B,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,sCAAsC,CAAC;AACrD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC;AAC5B,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mBAAmB,CAAC"}