@equinor/fusion-framework-module-http 6.2.5 → 6.3.0

package/dist/types/errors.d.ts

@@ -28,3 +28,24 @@ export declare class HttpJsonResponseError<TType = unknown, TResponse = Response
         data?: TType;
     });
 }
+/**
+ * Represents an error that occurs when handling a server-sent event (SSE) HTTP response.
+ *
+ * @template TType - The type of additional data associated with the error.
+ * @template TResponse - The type of the HTTP response object.
+ *
+ * @extends HttpResponseError<TResponse>
+ */
+export declare class ServerSentEventResponseError<TType = unknown, TResponse = Response> extends HttpResponseError<TResponse> {
+    static Name: string;
+    /**
+     * Creates a new instance of the error.
+     *
+     * @param message - The error message describing the cause of the error.
+     * @param response - The HTTP response associated with the error.
+     * @param options - Optional error options, which may include additional data of type `TType`.
+     */
+    constructor(message: string, response: TResponse, options?: ErrorOptions & {
+        data?: TType;
+    });
+}

package/dist/types/lib/client/client.d.ts

@@ -2,6 +2,7 @@ import { Subject } from 'rxjs';
 import type { Observable, ObservableInput } from 'rxjs';
 import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators';
 import type { BlobResult, FetchRequest, FetchRequestInit, FetchResponse, IHttpClient, JsonRequest, StreamResponse } from './types';
+import { type ServerSentEvent, type SseSelectorOptions } from '../selectors/sse-selector';
 /**
  * Configuration options for creating an `HttpClient` instance.
  *
@@ -114,6 +115,29 @@ export declare class HttpClient<TRequest extends FetchRequest = FetchRequest, TR
      * @returns A Promise that resolves to the blob result.
      */
     blob<T = BlobResult>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+    /**
+     * Initiates a Server-Sent Events (SSE) stream request to the specified path and returns a stream of events.
+     *
+     * @template T - The type of the event data expected from the SSE stream.
+     * @param path - The endpoint path to connect to for the SSE stream.
+     * @param args - Optional fetch request initialization options, including headers and abort signal.
+     * @param options - Optional selector options for customizing the SSE stream, excluding the abort signal.
+     *
+     * @returns A `StreamResponse` that emits `ServerSentEvent<T>` objects as they are received from the server.
+     *
+     * @example
+     * const sse$ = httpClient.sse(
+     *  '/events',
+     *  { method: 'POST', body: JSON.stringify({ prompt: 'tell me a joke' }) },
+     *  { eventFilter: ['message'] }
+     * );
+     * sse$.subscribe({
+     *  next: (event) => console.log(event),
+     *  error: (err) => console.error(err),
+     *  complete: () => console.log('Completed'),
+     * });
+     */
+    sse$<T = unknown>(path: string, args?: FetchRequestInit<ServerSentEvent<T>, TRequest, TResponse> | null, options?: Omit<SseSelectorOptions<T>, 'abortSignal'>): StreamResponse<ServerSentEvent<T>>;
     /** @deprecated */
     jsonAsync<T = unknown>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): Promise<T>;
     /**

package/dist/types/lib/operators/fetch-request.schema.d.ts

@@ -53,7 +53,7 @@ export declare const requestInitSchema: z.ZodObject<{
     signal: z.ZodOptional<z.ZodType<AbortSignal, z.ZodTypeDef, AbortSignal>>;
 }, "strip", z.ZodTypeAny, {
     body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
-    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    cache?: "default" | "no-cache" | "force-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
     credentials?: "include" | "omit" | "same-origin" | undefined;
     headers?: Headers | Record<string, string> | undefined;
     integrity?: string | undefined;
@@ -72,7 +72,7 @@ export declare const requestInitSchema: z.ZodObject<{
     browsingTopics?: boolean | undefined;
 }, {
     body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
-    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    cache?: "default" | "no-cache" | "force-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
     credentials?: "include" | "omit" | "same-origin" | undefined;
     headers?: Headers | Record<string, string> | undefined;
     integrity?: string | undefined;
@@ -129,7 +129,7 @@ export declare const fetchRequestSchema: z.ZodObject<{
     uri: string;
     body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
     path?: string | undefined;
-    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    cache?: "default" | "no-cache" | "force-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
     credentials?: "include" | "omit" | "same-origin" | undefined;
     headers?: Headers | Record<string, string> | undefined;
     integrity?: string | undefined;
@@ -150,7 +150,7 @@ export declare const fetchRequestSchema: z.ZodObject<{
     uri: string;
     body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | undefined;
     path?: string | undefined;
-    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+    cache?: "default" | "no-cache" | "force-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
     credentials?: "include" | "omit" | "same-origin" | undefined;
     headers?: Headers | Record<string, string> | undefined;
     integrity?: string | undefined;

package/dist/types/lib/operators/sse.operator.d.ts

@@ -0,0 +1,32 @@
+import type { OperatorFunction } from 'rxjs';
+import { type ServerSentEvent, type SseSelectorOptions } from '../selectors/sse-selector';
+/**
+ * An operator function for handling Server-Sent Events (SSE) in an RxJS pipeline.
+ *
+ * @template R - The type of the parsed data from the SSE.
+ * @template T - The type of the input `Response` object, defaults to `Response`.
+ *
+ * @param options - Configuration options for the SSE selector.
+ *
+ * @returns An `OperatorFunction` that transforms a stream of `Response` objects
+ * into a stream of `ServerSentEvent` objects containing parsed data of type `R`.
+ *
+ * @example
+ * ```typescript
+ * import { sseMap } from '@equinor/fusion-framework-module-http/operators';
+ * import { fromFetch } from 'rxjs/fetch';
+ *
+ * const response$ = fromFetch('https://example.com/sse', {
+ *   method: 'GET',
+ *   headers: {
+ *     'Accept': 'text/event-stream',
+ *   },
+ * }).pipe(
+ *   sseMap( { /* SSE selector options *\/ })
+ * ).subscribe((event) => {
+ *   console.log(event.data); // Process the parsed SSE data
+ * });
+ * ```
+ */
+export declare const sseMap: <R = unknown, T extends Response = Response>(options?: SseSelectorOptions<R>) => OperatorFunction<T, ServerSentEvent<R>>;
+export default sseMap;

package/dist/types/lib/selectors/sse-selector.d.ts

@@ -0,0 +1,63 @@
+import type { ResponseSelector } from '../client/types.js';
+/**
+ * A type representing a function that parses a string into a specific data type.
+ *
+ * @typeParam TData - The type of the parsed data. Defaults to `unknown` if not specified.
+ * @param data - The string input to be parsed.
+ * @returns The parsed data of type `TData`.
+ */
+export type DataParser<TData = unknown> = (data: string) => TData;
+/**
+ * Represents a Server-Sent Event (SSE) with optional fields.
+ */
+export type ServerSentEvent<TData = unknown> = {
+    id?: string;
+    event?: string;
+    data?: TData;
+    retry?: string;
+};
+/**
+ * Options for configuring the SSE (Server-Sent Events) selector.
+ */
+export type SseSelectorOptions<TData = unknown> = {
+    dataParser?: DataParser<TData>;
+    /**
+     * A string or an array of strings specifying the events to filter.
+     * Only events matching the filter will be processed. If not provided,
+     * all events will be processed.
+     */
+    eventFilter?: string | string[];
+    /**
+     * A boolean indicating whether to skip processing heartbeat events.
+     * Defaults to `false` if not specified.
+     */
+    skipHeartbeats?: boolean;
+    /**
+     * An `AbortSignal` that can be used to abort the SSE operation.
+     * Useful for managing the lifecycle of the SSE connection.
+     */
+    abortSignal?: AbortSignal | null;
+};
+/**
+ * A type alias for selecting and transforming Server-Sent Events (SSE) from an HTTP response.
+ *
+ * @template TData - The type of the data contained within the Server-Sent Event. Defaults to `unknown`.
+ * @template TResponse - The type of the HTTP response object. Defaults to `Response`.
+ *
+ * This selector is used to process and extract `ServerSentEvent<TData>` objects
+ * from an HTTP `Response` object, enabling custom handling of SSE data streams.
+ */
+export type SseSelector<TData = unknown, TResponse extends Response = Response> = ResponseSelector<ServerSentEvent<TData>, TResponse>;
+/**
+ * Transforms an SSE response into an Observable stream of parsed events.
+ * @param response - The HTTP response with Content-Type: text/event-stream.
+ * @param options - Optional configuration for event filtering and heartbeat handling.
+ * @param options.eventFilter - Filter events by type (single string or array).
+ * @param options.skipHeartbeats - Skip empty/heartbeat events if true.
+ * @param options.dataParser - Custom parser for the data field.
+ * @param options.abortSignal - Abort signal to cancel the stream.
+ * @returns An Observable emitting parsed ServerSentEvent objects.
+ * @throws ServerSentEventResponseError if response is invalid or stream fails.
+ */
+export declare const createSseSelector: <TData = unknown, TResponse extends Response = Response>(options?: SseSelectorOptions<TData>) => SseSelector<TData, TResponse>;
+export default createSseSelector;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.2.5";
+export declare const version = "6.3.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-http",
-  "version": "6.2.5",
+  "version": "6.3.0",
   "description": "",
   "main": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -40,8 +40,8 @@
   "dependencies": {
     "rxjs": "^7.8.1",
     "zod": "^3.23.8",
-    "@equinor/fusion-framework-module": "^4.3.8",
-    "@equinor/fusion-framework-module-msal": "^4.0.3"
+    "@equinor/fusion-framework-module": "^4.4.0",
+    "@equinor/fusion-framework-module-msal": "^4.0.4"
   },
   "devDependencies": {
     "typescript": "^5.8.2",

package/src/errors.ts

@@ -40,3 +40,30 @@ export class HttpJsonResponseError<
     this.data = options?.data;
   }
 }
+
+/**
+ * Represents an error that occurs when handling a server-sent event (SSE) HTTP response.
+ *
+ * @template TType - The type of additional data associated with the error.
+ * @template TResponse - The type of the HTTP response object.
+ *
+ * @extends HttpResponseError<TResponse>
+ */
+export class ServerSentEventResponseError<
+  TType = unknown,
+  TResponse = Response,
+> extends HttpResponseError<TResponse> {
+  static Name = 'ServerSentEventResponseError';
+
+  /**
+   * Creates a new instance of the error.
+   *
+   * @param message - The error message describing the cause of the error.
+   * @param response - The HTTP response associated with the error.
+   * @param options - Optional error options, which may include additional data of type `TType`.
+   */
+  constructor(message: string, response: TResponse, options?: ErrorOptions & { data?: TType }) {
+    super(message, response, options);
+    this.name = ServerSentEventResponseError.Name;
+  }
+}

package/src/lib/client/client.ts

@@ -14,10 +14,17 @@ import type {
   FetchResponse,
   IHttpClient,
   JsonRequest,
+  ResponseSelector,
   StreamResponse,
 } from './types';
 
 import { HttpResponseError } from '../../errors';
+import {
+  createSseSelector,
+  SseSelector,
+  type ServerSentEvent,
+  type SseSelectorOptions,
+} from '../selectors/sse-selector';
 
 /**
  * Configuration options for creating an `HttpClient` instance.
@@ -222,6 +229,51 @@ export class HttpClient<
     return firstValueFrom(this.blob$(path, args));
   }
 
+  /**
+   * Initiates a Server-Sent Events (SSE) stream request to the specified path and returns a stream of events.
+   *
+   * @template T - The type of the event data expected from the SSE stream.
+   * @param path - The endpoint path to connect to for the SSE stream.
+   * @param args - Optional fetch request initialization options, including headers and abort signal.
+   * @param options - Optional selector options for customizing the SSE stream, excluding the abort signal.
+   *
+   * @returns A `StreamResponse` that emits `ServerSentEvent<T>` objects as they are received from the server.
+   *
+   * @example
+   * const sse$ = httpClient.sse(
+   *  '/events',
+   *  { method: 'POST', body: JSON.stringify({ prompt: 'tell me a joke' }) },
+   *  { eventFilter: ['message'] }
+   * );
+   * sse$.subscribe({
+   *  next: (event) => console.log(event),
+   *  error: (err) => console.error(err),
+   *  complete: () => console.log('Completed'),
+   * });
+   */
+  public sse$<T = unknown>(
+    path: string,
+    args?: FetchRequestInit<ServerSentEvent<T>, TRequest, TResponse> | null,
+    options?: Omit<SseSelectorOptions<T>, 'abortSignal'>,
+  ): StreamResponse<ServerSentEvent<T>> {
+    // Setup default common headers for SSE
+    const headers = new Headers(args?.headers);
+    headers.append('Accept', 'text/event-stream');
+    headers.append('Content-Type', 'text/event-stream');
+    headers.append('Cache-Control', 'no-cache');
+    headers.append('Connection', 'keep-alive');
+
+    // Create the selector using the provided options and the abort signal from args
+    const selector = createSseSelector<T>({ ...options, abortSignal: args?.signal });
+
+    // Call the fetch$ method with the provided path and the constructed init object
+    return this._fetch$(path, { selector, ...args, headers } as FetchRequestInit<
+      ServerSentEvent<T>,
+      TRequest,
+      TResponse
+    >);
+  }
+
   /** @deprecated */
   public jsonAsync<T = unknown>(
     path: string,

package/src/lib/operators/sse.operator.ts

@@ -0,0 +1,44 @@
+import type { OperatorFunction } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import {
+  createSseSelector,
+  type ServerSentEvent,
+  type SseSelectorOptions,
+} from '../selectors/sse-selector';
+
+/**
+ * An operator function for handling Server-Sent Events (SSE) in an RxJS pipeline.
+ *
+ * @template R - The type of the parsed data from the SSE.
+ * @template T - The type of the input `Response` object, defaults to `Response`.
+ *
+ * @param options - Configuration options for the SSE selector.
+ *
+ * @returns An `OperatorFunction` that transforms a stream of `Response` objects
+ * into a stream of `ServerSentEvent` objects containing parsed data of type `R`.
+ *
+ * @example
+ * ```typescript
+ * import { sseMap } from '@equinor/fusion-framework-module-http/operators';
+ * import { fromFetch } from 'rxjs/fetch';
+ *
+ * const response$ = fromFetch('https://example.com/sse', {
+ *   method: 'GET',
+ *   headers: {
+ *     'Accept': 'text/event-stream',
+ *   },
+ * }).pipe(
+ *   sseMap( { /* SSE selector options *\/ })
+ * ).subscribe((event) => {
+ *   console.log(event.data); // Process the parsed SSE data
+ * });
+ * ```
+ */
+export const sseMap =
+  <R = unknown, T extends Response = Response>(
+    options?: SseSelectorOptions<R>,
+  ): OperatorFunction<T, ServerSentEvent<R>> =>
+  (source) =>
+    source.pipe(switchMap(createSseSelector<R, T>(options)));
+
+export default sseMap;

package/src/lib/selectors/sse-selector.ts

@@ -0,0 +1,262 @@
+import { EMPTY, from, fromEvent, type Observable } from 'rxjs';
+import { finalize, takeUntil } from 'rxjs/operators';
+
+import type { ResponseSelector } from '../client/types.js';
+import { ServerSentEventResponseError } from '../../errors.js';
+
+/**
+ * A type representing a function that parses a string into a specific data type.
+ *
+ * @typeParam TData - The type of the parsed data. Defaults to `unknown` if not specified.
+ * @param data - The string input to be parsed.
+ * @returns The parsed data of type `TData`.
+ */
+export type DataParser<TData = unknown> = (data: string) => TData;
+
+const defaultDataParser: DataParser = (data: string) => {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+};
+
+/**
+ * Represents a Server-Sent Event (SSE) with optional fields.
+ */
+export type ServerSentEvent<TData = unknown> = {
+  id?: string;
+  event?: string;
+  data?: TData;
+  retry?: string;
+};
+
+/**
+ * Parses a string containing Server-Sent Events (SSE) data into individual event objects.
+ *
+ * @template TData - The type of the parsed `data` field in the event.
+ * @param text - The raw SSE data as a string, where events are separated by double newlines.
+ * @param options - Optional configuration for parsing the events.
+ * @param options.dataParser - A custom parser function for the `data` field. Defaults to JSON parsing,
+ *                             falling back to returning the raw string if parsing fails.
+ *
+ * @returns A generator that yields `ServerSentEvent` objects parsed from the input string.
+ *
+ * @remarks
+ * - Empty lines and events with no fields are ignored.
+ * - If the `data` field cannot be parsed as JSON, it is returned as a plain string.
+ * - Fields other than `data` are stored as strings in the resulting `ServerSentEvent` object.
+ *
+ * @example
+ * ```typescript
+ * const sseData = `
+ * id: 1
+ * event: message
+ * data: {"key":"value"}
+ *
+ * id: 2
+ * event: update
+ * data: plain text
+ * `;
+ *
+ * for (const event of parseEvents(sseData)) {
+ *   console.log(event);
+ * }
+ * // Output:
+ * // { id: "1", event: "message", data: { key: "value" } }
+ * // { id: "2", event: "update", data: "plain text" }
+ * ```
+ */
+function* parseEvents<TData = unknown>(
+  text: string,
+  options?: { dataParser?: DataParser<TData> },
+): Generator<ServerSentEvent<TData>> {
+  // Split the input string into individual event strings using double newline as separator
+  const eventStrings = text.split('\n\n');
+
+  const dataParser = options?.dataParser || (defaultDataParser as DataParser<TData>);
+
+  // Iterate through each event string
+  for (const eventStr of eventStrings) {
+    // Skip empty event strings (after trimming whitespace)
+    if (!eventStr.trim()) continue;
+
+    // Split the event string into lines (fields) using single newline
+    const lines = eventStr.split('\n');
+
+    // Use reduce to process each line in the event string
+    const event = lines.reduce(
+      (event, line) => {
+        // Skip empty lines
+        if (!line) return event;
+
+        // Find the index of the first colon, which separates field name and value
+        const colonIndex = line.indexOf(':');
+
+        // Skip lines without a colon (invalid format)
+        if (colonIndex === -1) return event;
+
+        // Extract the field name (before colon) and trim whitespace
+        const field = line.slice(0, colonIndex).trim();
+        // Extract the field value (after colon) and trim whitespace
+        const value = line.slice(colonIndex + 1).trim();
+
+        // Handle the 'data' field specially, attempting JSON parsing
+        if (field === 'data') {
+          event.data = dataParser(value);
+        } else {
+          // For non-data fields, assign the value as a string to the event object
+          (event as Record<string, unknown>)[field] = value;
+        }
+
+        return event;
+      },
+      {} as ServerSentEvent<TData>,
+    );
+
+    // Only emit the event to the results if it has at least one field
+    if (Object.keys(event).length) {
+      yield event;
+    }
+  }
+}
+
+async function* readStream<TData>(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  options?: {
+    dataParser?: DataParser<TData>;
+    skipHeartbeats?: boolean;
+    eventFilter?: string | string[];
+  },
+): AsyncGenerator<ServerSentEvent<TData>> {
+  const skipHeartbeats = !!options?.skipHeartbeats;
+
+  const eventFilter = options?.eventFilter
+    ? Array.isArray(options.eventFilter)
+      ? options.eventFilter
+      : [options.eventFilter]
+    : null;
+
+  const decoder = new TextDecoder();
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    const text = decoder.decode(value, { stream: true });
+    const events = parseEvents<TData>(text, { dataParser: options?.dataParser });
+    for (const event of events) {
+      if (event.retry) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, Number.parseInt(event.retry ?? '300', 10)),
+        );
+        continue;
+      }
+      if (skipHeartbeats) {
+        // Skip comment-based heartbeats (no event, data, or id)
+        if (!event.event && !event.data && !event.id) {
+          continue;
+        }
+        // Skip named heartbeat events (e.g., event: heartbeat or event: ping)
+        if (event.event && ['heartbeat', 'ping'].includes(event.event)) {
+          continue;
+        }
+      }
+      if (!eventFilter || (event.event && eventFilter.includes(event.event))) {
+        yield event as ServerSentEvent<TData>;
+      }
+    }
+  }
+}
+
+/**
+ * Options for configuring the SSE (Server-Sent Events) selector.
+ */
+export type SseSelectorOptions<TData = unknown> = {
+  dataParser?: DataParser<TData>;
+  /**
+   * A string or an array of strings specifying the events to filter.
+   * Only events matching the filter will be processed. If not provided,
+   * all events will be processed.
+   */
+  eventFilter?: string | string[];
+
+  /**
+   * A boolean indicating whether to skip processing heartbeat events.
+   * Defaults to `false` if not specified.
+   */
+  skipHeartbeats?: boolean;
+
+  /**
+   * An `AbortSignal` that can be used to abort the SSE operation.
+   * Useful for managing the lifecycle of the SSE connection.
+   */
+  abortSignal?: AbortSignal | null;
+};
+
+/**
+ * A type alias for selecting and transforming Server-Sent Events (SSE) from an HTTP response.
+ *
+ * @template TData - The type of the data contained within the Server-Sent Event. Defaults to `unknown`.
+ * @template TResponse - The type of the HTTP response object. Defaults to `Response`.
+ *
+ * This selector is used to process and extract `ServerSentEvent<TData>` objects
+ * from an HTTP `Response` object, enabling custom handling of SSE data streams.
+ */
+export type SseSelector<TData = unknown, TResponse extends Response = Response> = ResponseSelector<
+  ServerSentEvent<TData>,
+  TResponse
+>;
+
+/**
+ * Transforms an SSE response into an Observable stream of parsed events.
+ * @param response - The HTTP response with Content-Type: text/event-stream.
+ * @param options - Optional configuration for event filtering and heartbeat handling.
+ * @param options.eventFilter - Filter events by type (single string or array).
+ * @param options.skipHeartbeats - Skip empty/heartbeat events if true.
+ * @param options.dataParser - Custom parser for the data field.
+ * @param options.abortSignal - Abort signal to cancel the stream.
+ * @returns An Observable emitting parsed ServerSentEvent objects.
+ * @throws ServerSentEventResponseError if response is invalid or stream fails.
+ */
+export const createSseSelector = <TData = unknown, TResponse extends Response = Response>(
+  options?: SseSelectorOptions<TData>,
+): SseSelector<TData, TResponse> => {
+  return (response: TResponse): Observable<ServerSentEvent<TData>> => {
+    if (!response.ok) {
+      throw new ServerSentEventResponseError(`HTTP error! Status: ${response.status}`, response);
+    }
+
+    if (!response.body) {
+      throw new ServerSentEventResponseError('Response body is not readable', response);
+    }
+
+    if (!response.headers.get('Content-Type')?.includes('text/event-stream')) {
+      throw new ServerSentEventResponseError('Response is not a text/event-stream', response);
+    }
+
+    const reader = response.body.getReader();
+
+    return from(
+      readStream<TData>(reader, {
+        dataParser: options?.dataParser,
+        skipHeartbeats: options?.skipHeartbeats,
+        eventFilter: options?.eventFilter,
+      }),
+    ).pipe(
+      // Stop reading if the abort signal is triggered
+      takeUntil(options?.abortSignal ? fromEvent(options.abortSignal, 'abort') : EMPTY),
+      finalize(async () => {
+        // cancel just in case of a pre-mature exit
+        await reader.cancel().catch(() => {
+          /** ignore cancellation errors */
+        });
+        reader.releaseLock();
+      }),
+    );
+  };
+};
+
+export default createSseSelector;

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '6.2.5';
+export const version = '6.3.0';