@duplojs/http 0.7.4 → 0.8.4

package/dist/client/promiseRequest.d.ts

@@ -1,10 +1,10 @@
-import { type NeverCoalescing, type MaybePromise } from "@duplojs/utils";
+import { type NeverCoalescing, type MaybePromise, type O } from "@duplojs/utils";
 import * as EE from "@duplojs/utils/either";
 import { type RequestErrorContent } from "./unexpectedResponseError";
-import { type NotPredictedClientResponse, type ClientResponse, type PromiseRequestParams, type Hooks, type NotPredictedResponseHook, type ErrorHook } from "./types";
-type MaybeResponse<GenericClientResponse extends ClientResponse = ClientResponse> = (EE.Right<"response", GenericClientResponse> | EE.Left<"request-error", RequestErrorContent>);
-type MaybeWantedResponse<GenericWantedClientResponse extends ClientResponse = ClientResponse, GenericUnexpectClientResponse extends ClientResponse = ClientResponse> = (EE.Right<"response", GenericWantedClientResponse> | EE.Left<"unexpect-response", GenericUnexpectClientResponse> | EE.Left<"request-error", RequestErrorContent>);
-export declare class PromiseRequest<GenericHookParams extends Record<string, unknown> = Record<string, unknown>, GenericClientResponse extends ClientResponse<GenericHookParams> = ClientResponse<GenericHookParams>> extends Promise<MaybeResponse<GenericClientResponse | NotPredictedClientResponse<GenericHookParams>>> {
+import { type PromiseRequestParams, type Hooks, type NotPredictedResponseHook, type ErrorHook, type ClientEventsResponse, type AllClientResponse, type AllNotPredictedClientResponse, type ClientEventsResponseHandler, type ServerEvent } from "./types";
+type MaybeResponse<GenericClientResponse extends AllClientResponse = AllClientResponse> = (EE.Right<"response", GenericClientResponse> | EE.Left<"request-error", RequestErrorContent>);
+type MaybeWantedResponse<GenericWantedClientResponse extends AllClientResponse = AllClientResponse, GenericUnexpectClientResponse extends AllClientResponse = AllClientResponse> = (EE.Right<"response", GenericWantedClientResponse> | EE.Left<"unexpect-response", GenericUnexpectClientResponse> | EE.Left<"request-error", RequestErrorContent>);
+export declare class PromiseRequest<GenericHookParams extends Record<string, unknown> = Record<string, unknown>, GenericClientResponse extends AllClientResponse<GenericHookParams> = AllClientResponse<GenericHookParams>> extends Promise<MaybeResponse<GenericClientResponse | AllNotPredictedClientResponse<GenericHookParams>>> {
     params: PromiseRequestParams;
     readonly hooks: Partial<Hooks>;
     constructor(params: PromiseRequestParams);
@@ -13,77 +13,94 @@ export declare class PromiseRequest<GenericHookParams extends Record<string, unk
     whenNotPredictedResponse(callback: NotPredictedResponseHook<GenericHookParams>): this;
     whenInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>>(information: GenericInformation | GenericInformation[], callback: (response: NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
-    } : never>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    } : never>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenCode<GenericCode extends GenericClientResponse["code"]>(code: GenericCode | GenericCode[], callback: (response: NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
         code: GenericCode;
-    } : never>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    } : never>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenInformationalResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `1${number}`;
-    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    }>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenSuccessfulResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}`;
-    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    }>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenRedirectionResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `3${number}`;
-    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    }>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenClientErrorResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `4${number}`;
-    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    }>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenServerErrorResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `5${number}`;
-    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    }>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenExpectedResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}` | `4${number}`;
-    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    }>, AllClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenError(callback: ErrorHook<GenericHookParams>): this;
+    whenReceiveServerEvent<GenericEvent extends (GenericClientResponse extends ClientEventsResponseHandler<infer InferredEvent> ? InferredEvent : never), GenericEventName extends GenericEvent["event"]>(eventName: GenericEventName, callback: (event: NoInfer<NeverCoalescing<Extract<GenericEvent, {
+        event: GenericEventName;
+    }>, ServerEvent>>, response: NeverCoalescing<Extract<GenericClientResponse, ClientEventsResponseHandler<GenericEvent>>, ClientEventsResponse>) => MaybePromise<void>): this;
     iWantInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>, GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
-    } : never>, ClientResponse<GenericHookParams>>>(information: GenericInformation | GenericInformation[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    } : never>, AllClientResponse<GenericHookParams>>>(information: GenericInformation | GenericInformation[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantCode<GenericCode extends GenericClientResponse["code"], GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
         code: GenericCode;
-    } : never>, ClientResponse<GenericHookParams>>>(code: GenericCode | GenericCode[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    } : never>, AllClientResponse<GenericHookParams>>>(code: GenericCode | GenericCode[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantInformationalResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `1${number}`;
-    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    }>, AllClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantSuccessfulResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}`;
-    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    }>, AllClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantRedirectionResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `3${number}`;
-    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    }>, AllClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantClientErrorResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `4${number}`;
-    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    }>, AllClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantServerErrorResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `5${number}`;
-    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    }>, AllClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantExpectedResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}` | `4${number}`;
-    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
+    }>, AllClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
+    iSelectExpectedResponseByInformation<const GenericSelector extends Record<Extract<GenericClientResponse["information"], string>, boolean>, GenericResponse extends Extract<GenericClientResponse, {
+        information: O.GetPropsWithValue<GenericSelector, true>;
+    } | {
+        information: O.GetPropsWithValue<GenericSelector, boolean>;
+    }>, GenericUnexpectedResponse extends Extract<GenericClientResponse, {
+        information: O.GetPropsWithValue<GenericSelector, false>;
+    } | {
+        information: O.GetPropsWithValue<GenericSelector, boolean>;
+    }>>(selector: GenericSelector): Promise<MaybeWantedResponse<NeverCoalescing<GenericResponse, AllClientResponse<GenericHookParams>>, NeverCoalescing<GenericUnexpectedResponse, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;
     iWantInformationOrThrow<GenericInformation extends Extract<GenericClientResponse["information"], string>>(information: GenericInformation | GenericInformation[]): Promise<NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
-    } : never>, ClientResponse<GenericHookParams>>>;
+    } : never>, AllClientResponse<GenericHookParams>>>;
     iWantCodeOrThrow<GenericCode extends GenericClientResponse["code"]>(code: GenericCode | GenericCode[]): Promise<NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
         code: GenericCode;
-    } : never>, ClientResponse<GenericHookParams>>>;
+    } : never>, AllClientResponse<GenericHookParams>>>;
     iWantInformationalResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `1${number}`;
-    }>, ClientResponse<GenericHookParams>>>;
+    }>, AllClientResponse<GenericHookParams>>>;
     iWantSuccessfulResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}`;
-    }>, ClientResponse<GenericHookParams>>>;
+    }>, AllClientResponse<GenericHookParams>>>;
     iWantRedirectionResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `3${number}`;
-    }>, ClientResponse<GenericHookParams>>>;
+    }>, AllClientResponse<GenericHookParams>>>;
     iWantClientErrorResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `4${number}`;
-    }>, ClientResponse<GenericHookParams>>>;
+    }>, AllClientResponse<GenericHookParams>>>;
     iWantServerErrorResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `5${number}`;
-    }>, ClientResponse<GenericHookParams>>>;
+    }>, AllClientResponse<GenericHookParams>>>;
     iWantExpectedResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}` | `4${number}`;
-    }>, ClientResponse<GenericHookParams>>>;
+    }>, AllClientResponse<GenericHookParams>>>;
+    iSelectExpectedResponseByInformationOrThrow<const GenericSelector extends Record<Extract<GenericClientResponse["information"], string>, boolean>, GenericResponse extends Extract<GenericClientResponse, {
+        information: O.GetPropsWithValue<GenericSelector, true>;
+    } | {
+        information: O.GetPropsWithValue<GenericSelector, boolean>;
+    }>>(selector: GenericSelector): Promise<NeverCoalescing<GenericResponse, AllClientResponse<GenericHookParams>>>;
     static get [Symbol.species](): PromiseConstructor;
     static fetch<GenericPromiseRequestParams extends PromiseRequestParams>(requestParams: GenericPromiseRequestParams): Promise<MaybeResponse>;
 }

package/dist/client/promiseRequest.mjs

@@ -7,6 +7,7 @@ import * as EE from '@duplojs/utils/either';
 import * as SS from '@duplojs/utils/string';
 import * as AA from '@duplojs/utils/array';
 import { UnexpectedInformationResponseError, UnexpectedCodeResponseError, UnexpectedResponseTypeError, UnexpectedResponseError } from './unexpectedResponseError.mjs';
+import { makeClientEventsResponse } from './serverSentEvents.mjs';
 
 class PromiseRequest extends Promise {
     params;
@@ -42,7 +43,7 @@ class PromiseRequest extends Promise {
             return EE.right("response", response);
         })
             .then(async (result) => {
-            if (EE.eitherFutureErrorKind.has(result)) {
+            if (EE.futureErrorKind.has(result)) {
                 const error = unwrap(result);
                 await launchErrorHook(params.hooks.error, this.hooks.error ?? [], error, params);
                 return EE.left("request-error", {
@@ -123,10 +124,22 @@ class PromiseRequest extends Promise {
         this.hooks.error.push(callback);
         return this;
     }
+    whenReceiveServerEvent(eventName, callback) {
+        void this.then(EE.whenIsRight((response) => {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && Symbol.asyncIterator in response) {
+                response.onReceiveEvent(eventName, callback);
+            }
+        }));
+        return this;
+    }
     iWantInformation(information) {
         const formattedInformation = AA.coalescing(information);
         return this.then(EE.whenIsRight((response) => {
-            if (response.information !== undefined
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && response.information !== undefined
                 && AA.includes(formattedInformation, response.information)) {
                 return EE.right("response", response);
             }
@@ -136,7 +149,9 @@ class PromiseRequest extends Promise {
     iWantCode(code) {
         const formattedCode = AA.coalescing(code);
         return this.then(EE.whenIsRight((response) => {
-            if (AA.includes(formattedCode, response.code)) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && AA.includes(formattedCode, response.code)) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -144,7 +159,9 @@ class PromiseRequest extends Promise {
     }
     iWantInformationalResponse() {
         return this.then(EE.whenIsRight((response) => {
-            if (SS.startsWith(response.code, "1")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS.startsWith(response.code, "1")) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -152,7 +169,9 @@ class PromiseRequest extends Promise {
     }
     iWantSuccessfulResponse() {
         return this.then(EE.whenIsRight((response) => {
-            if (SS.startsWith(response.code, "2")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS.startsWith(response.code, "2")) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -160,7 +179,9 @@ class PromiseRequest extends Promise {
     }
     iWantRedirectionResponse() {
         return this.then(EE.whenIsRight((response) => {
-            if (SS.startsWith(response.code, "3")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS.startsWith(response.code, "3")) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -168,7 +189,9 @@ class PromiseRequest extends Promise {
     }
     iWantClientErrorResponse() {
         return this.then(EE.whenIsRight((response) => {
-            if (SS.startsWith(response.code, "4")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS.startsWith(response.code, "4")) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -176,7 +199,9 @@ class PromiseRequest extends Promise {
     }
     iWantServerErrorResponse() {
         return this.then(EE.whenIsRight((response) => {
-            if (SS.startsWith(response.code, "5")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS.startsWith(response.code, "5")) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -184,7 +209,20 @@ class PromiseRequest extends Promise {
     }
     iWantExpectedResponse() {
         return this.then(EE.whenIsRight((response) => {
-            if (SS.startsWith(response.code, "2") || SS.startsWith(response.code, "4")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && (SS.startsWith(response.code, "2")
+                    || SS.startsWith(response.code, "4"))) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iSelectExpectedResponseByInformation(selector) {
+        return this.then(EE.whenIsRight((response) => {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && selector[(response.information ?? "")] === true) {
                 return EE.right("response", response);
             }
             return EE.left("unexpect-response", response);
@@ -270,6 +308,16 @@ class PromiseRequest extends Promise {
             throw new UnexpectedResponseError(unwrap(maybeResponse));
         });
     }
+    iSelectExpectedResponseByInformationOrThrow(selector) {
+        return this
+            .iSelectExpectedResponseByInformation(selector)
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseError(unwrap(maybeResponse));
+        });
+    }
     static get [Symbol.species]() {
         return Promise;
     }
@@ -303,28 +351,37 @@ class PromiseRequest extends Promise {
                 }
             }
         }
-        return fetch(`${requestParams.baseUrl}${url}`, {
+        const fetchUrl = `${requestParams.baseUrl}${url}`;
+        const fetchInitParams = {
             ...requestParams.initParams,
             headers: headers,
             method: requestParams.method,
             body: body,
-        })
+            signal: requestParams.abortController.signal,
+        };
+        return fetch(fetchUrl, fetchInitParams)
             .then((response) => getBody(response)
-            .then((body) => EE.right("response", {
-            body,
-            information: response.headers.get(requestParams.informationHeaderKey) || undefined,
-            code: response.status.toString(),
-            ok: (response.status < 500)
-                ? response.ok
-                : null,
-            headers: response.headers,
-            type: response.type,
-            url: response.url,
-            redirected: response.redirected,
-            raw: response,
-            requestParams,
-            predicted: response.headers.get(requestParams.predictedHeaderKey) !== null,
-        })))
+            .then((body) => {
+            const clientResponse = {
+                body,
+                information: response.headers.get(requestParams.informationHeaderKey) ?? undefined,
+                code: response.status.toString(),
+                ok: (response.status < 500)
+                    ? response.ok
+                    : null,
+                headers: response.headers,
+                type: response.type,
+                url: response.url,
+                redirected: response.redirected,
+                raw: response,
+                requestParams,
+                predicted: response.headers.get(requestParams.predictedHeaderKey) !== null,
+            };
+            if (response.headers.get("content-type")?.includes("text/event-stream")) {
+                return EE.right("response", makeClientEventsResponse(clientResponse, fetchUrl, fetchInitParams));
+            }
+            return EE.right("response", clientResponse);
+        }))
             .catch((error) => EE.left("request-error", {
             error,
             requestParams,

package/dist/client/queryToString.cjs

@@ -6,7 +6,7 @@ function queryToString(query) {
     }
     return Object.entries(query)
         .reduce((pv, [key, value]) => {
-        if (!value) {
+        if (value === undefined) {
             return pv;
         }
         if (value instanceof Array) {

package/dist/client/queryToString.mjs

@@ -4,7 +4,7 @@ function queryToString(query) {
     }
     return Object.entries(query)
         .reduce((pv, [key, value]) => {
-        if (!value) {
+        if (value === undefined) {
             return pv;
         }
         if (value instanceof Array) {

package/dist/client/serverSentEvents.cjs

@@ -0,0 +1,231 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var GG = require('@duplojs/utils/generator');
+var SS = require('@duplojs/utils/string');
+var AA = require('@duplojs/utils/array');
+var hooks = require('./hooks.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var GG__namespace = /*#__PURE__*/_interopNamespaceDefault(GG);
+var SS__namespace = /*#__PURE__*/_interopNamespaceDefault(SS);
+var AA__namespace = /*#__PURE__*/_interopNamespaceDefault(AA);
+
+const closeReason = Symbol("CloseReason");
+const endMessageRegexp = /\n\n|\r\r|\r\n\r\n/;
+const eventPayloadRegexp = /^(?<field>event|data|id|retry|content-type): ?(?<value>.*)$/gm;
+const validRetryRegexp = /^[0-9]+$/;
+const nullIdRegexp = /\0|\n|\r/;
+function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
+    let reader = response.raw.body?.getReader();
+    let abortController = response.requestParams.abortController;
+    const createEventResponse = (eventsReaderGenerator) => {
+        let closeServerEvent = undefined;
+        let beforeRetryServerEvent = undefined;
+        let errorServerEvent = undefined;
+        let startServerEvent = undefined;
+        let receiveEventServerEvent = undefined;
+        const eventResponse = {
+            ...response,
+            closeEventStream: () => void abortController.abort(closeReason),
+            onReceiveEvent: (eventName, callback) => {
+                receiveEventServerEvent ??= [];
+                receiveEventServerEvent.push((receiveEvent) => receiveEvent.event === eventName
+                    ? callback(receiveEvent, eventResponse)
+                    : undefined);
+                return eventResponse;
+            },
+            onStreamEvent: (event, callback) => {
+                if (event === "receiveServerEvents") {
+                    receiveEventServerEvent ??= [];
+                    receiveEventServerEvent.push(callback);
+                }
+                else if (event === "beforeRetry") {
+                    beforeRetryServerEvent ??= [];
+                    beforeRetryServerEvent.push(callback);
+                }
+                else if (event === "close") {
+                    closeServerEvent ??= [];
+                    closeServerEvent.push(callback);
+                }
+                else if (event === "start") {
+                    startServerEvent ??= [];
+                    startServerEvent.push(callback);
+                }
+                else if (event === "error") {
+                    errorServerEvent ??= [];
+                    errorServerEvent.push(callback);
+                }
+                return eventResponse;
+            },
+            async consumeEventStream() {
+                for await (const __ of eventResponse) { }
+            },
+            [Symbol.asyncIterator]: async function* () {
+                await hooks.launchStartServerEventHook(response.requestParams.hooks.startServerEvent, startServerEvent ?? [], eventResponse).catch(console.error);
+                const onError = (error) => hooks.launchErrorServerEventHook(response.requestParams.hooks.errorServerEvent, errorServerEvent ?? [], error, eventResponse).catch(console.error);
+                const generator = eventsReaderGenerator(onError, () => hooks.launchBeforeRetryServerEventHook(response.requestParams.hooks.beforeRetryServerEvent, beforeRetryServerEvent ?? [], eventResponse).catch(console.error));
+                try {
+                    for await (const event of generator) {
+                        await hooks.launchReceiveEventServerEventHook(response.requestParams.hooks.receiveEventServerEvent, receiveEventServerEvent ?? [], event, eventResponse).catch(console.error);
+                        yield event;
+                    }
+                }
+                finally {
+                    await hooks.launchCloseServerEventHook(response.requestParams.hooks.closeServerEvent, closeServerEvent ?? [], eventResponse).catch(console.error);
+                }
+            },
+        };
+        return eventResponse;
+    };
+    if (!reader
+        || response.code === "204"
+        || !response.headers.get("content-type")?.includes("text/event-stream")) {
+        return createEventResponse(async function* () { });
+    }
+    return createEventResponse((emitError, emitBeforeRetry) => {
+        let lastId = response.requestParams.headers?.["last-event-id"];
+        let retry = 3000;
+        return utils.pipe(GG__namespace.asyncLoop(async ({ next, exit }) => {
+            try {
+                if (abortController.signal.aborted) {
+                    return exit();
+                }
+                else if (reader) {
+                    const chunk = await reader.read();
+                    if (chunk.done) {
+                        reader = undefined;
+                    }
+                    return next(chunk);
+                }
+                else {
+                    abortController = new AbortController();
+                    await utils.sleep(retry);
+                    await emitBeforeRetry();
+                    const fetchResponse = await fetch(fetchUrl, {
+                        ...fetchInitParams,
+                        headers: {
+                            ...fetchInitParams.headers,
+                            ...(typeof lastId === "string"
+                                ? { "last-event-id": lastId }
+                                : undefined),
+                        },
+                        signal: abortController.signal,
+                    });
+                    const fetchInformation = fetchResponse.headers.get(response.requestParams.informationHeaderKey);
+                    if (fetchResponse.status !== 204
+                        && fetchResponse.headers.get("content-type")?.includes("text/event-stream")
+                        && fetchResponse.body
+                        && ((fetchInformation === null
+                            && response.information === undefined)
+                            || fetchInformation === response.information)) {
+                        reader = fetchResponse.body.getReader();
+                        return next();
+                    }
+                    return exit();
+                }
+            }
+            catch (error) {
+                if (error !== closeReason) {
+                    await emitError(error);
+                }
+                reader = undefined;
+                return next();
+            }
+        }), async function* (chunkGenerator) {
+            const decoder = new TextDecoder("utf-8");
+            let buffer = "";
+            for await (const chunk of chunkGenerator) {
+                buffer += decoder.decode(chunk.value, { stream: true });
+                if (SS__namespace.test(buffer, endMessageRegexp)) {
+                    const events = SS__namespace.split(buffer, endMessageRegexp);
+                    buffer = AA__namespace.last(events);
+                    const restEvents = AA__namespace.pop(events);
+                    for (const event of restEvents) {
+                        yield event;
+                    }
+                }
+                if (chunk.done) {
+                    buffer = "";
+                }
+            }
+        }, async function* (chunkStringGenerator) {
+            for await (const stringChunk of chunkStringGenerator) {
+                const eventContent = GG__namespace.reduce(SS__namespace.extractAll(stringChunk, eventPayloadRegexp), GG__namespace.reduceFrom({}), ({ lastValue, element, next }) => {
+                    const { field, value } = element.namedGroups;
+                    if (field === "data") {
+                        return next({
+                            ...lastValue,
+                            data: lastValue.data === undefined
+                                ? value
+                                : `${lastValue.data}\n${value}`,
+                        });
+                    }
+                    else if (field === "retry") {
+                        const retry = SS__namespace.test(value, validRetryRegexp)
+                            ? parseInt(value, 10)
+                            : undefined;
+                        return next({
+                            ...lastValue,
+                            retry: typeof retry === "number" && !isNaN(retry)
+                                ? retry
+                                : undefined,
+                        });
+                    }
+                    else if (field === "id") {
+                        return next({
+                            ...lastValue,
+                            id: !SS__namespace.test(value, nullIdRegexp)
+                                ? value
+                                : undefined,
+                        });
+                    }
+                    return next({
+                        ...lastValue,
+                        [field]: value,
+                    });
+                });
+                if (typeof eventContent.id === "string") {
+                    lastId = eventContent.id;
+                }
+                if (typeof eventContent.retry === "number") {
+                    retry = eventContent.retry;
+                }
+                if (eventContent.data === undefined) {
+                    continue;
+                }
+                try {
+                    yield {
+                        event: eventContent.event || "message",
+                        data: eventContent["content-type"]?.includes("application/json")
+                            ? JSON.parse(eventContent.data)
+                            : eventContent.data,
+                        id: eventContent.id,
+                        retry: eventContent.retry,
+                    };
+                }
+                catch (error) {
+                    await emitError(error);
+                }
+            }
+        });
+    });
+}
+
+exports.makeClientEventsResponse = makeClientEventsResponse;

package/dist/client/serverSentEvents.d.ts

@@ -0,0 +1,2 @@
+import { type ClientEventsResponse, type ClientResponse } from "./types";
+export declare function makeClientEventsResponse(response: ClientResponse, fetchUrl: string, fetchInitParams: RequestInit): ClientEventsResponse;