@duplojs/http 0.7.1 → 0.8.4

package/dist/client/getBody.cjs

@@ -5,15 +5,15 @@ function getBody(response) {
     if (!responseContentType) {
         return Promise.resolve(undefined);
     }
+    else if (responseContentType.includes("text/event-stream")) {
+        return Promise.resolve(undefined);
+    }
     else if (responseContentType.includes("json")) {
         return response.json();
     }
     else if (responseContentType.includes("text")) {
         return response.text();
     }
-    else if (responseContentType.includes("form-data")) {
-        return response.formData();
-    }
     else {
         return Promise.resolve(undefined);
     }

package/dist/client/getBody.mjs

@@ -3,15 +3,15 @@ function getBody(response) {
     if (!responseContentType) {
         return Promise.resolve(undefined);
     }
+    else if (responseContentType.includes("text/event-stream")) {
+        return Promise.resolve(undefined);
+    }
     else if (responseContentType.includes("json")) {
         return response.json();
     }
     else if (responseContentType.includes("text")) {
         return response.text();
     }
-    else if (responseContentType.includes("form-data")) {
-        return response.formData();
-    }
     else {
         return Promise.resolve(undefined);
     }

package/dist/client/hooks.cjs

@@ -68,12 +68,57 @@ async function launchErrorHook(clientHook, promiseRequestHook, error, requestPar
         await clientHook[index](error, requestParams);
     }
 }
+async function launchCloseServerEventHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchBeforeRetryServerEventHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchErrorServerEventHook(clientHook, promiseRequestHook, error, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](error, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](error, response);
+    }
+}
+async function launchStartServerEventHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchReceiveEventServerEventHook(clientHook, promiseRequestHook, event, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](event, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](event, response);
+    }
+}
 
+exports.launchBeforeRetryServerEventHook = launchBeforeRetryServerEventHook;
+exports.launchCloseServerEventHook = launchCloseServerEventHook;
 exports.launchCodeHook = launchCodeHook;
 exports.launchErrorHook = launchErrorHook;
+exports.launchErrorServerEventHook = launchErrorServerEventHook;
 exports.launchExpectedResponseHook = launchExpectedResponseHook;
 exports.launchInformationHook = launchInformationHook;
 exports.launchNotPredictedHook = launchNotPredictedHook;
+exports.launchReceiveEventServerEventHook = launchReceiveEventServerEventHook;
 exports.launchRequestHook = launchRequestHook;
 exports.launchResponseHook = launchResponseHook;
 exports.launchResponseTypeHook = launchResponseTypeHook;
+exports.launchStartServerEventHook = launchStartServerEventHook;

package/dist/client/hooks.d.ts

@@ -1,4 +1,4 @@
-import { type CodeHook, type ErrorHook, type InformationHook, type NotPredictedResponseHook, type RequestHook, type ResponseHook, type ResponseTypeHook, type PromiseRequestParams, type NotPredictedClientResponse, type ClientResponse } from "./types";
+import { type CodeHook, type ErrorHook, type InformationHook, type NotPredictedResponseHook, type RequestHook, type ResponseHook, type ResponseTypeHook, type PromiseRequestParams, type NotPredictedClientResponse, type ClientResponse, type CloseServerEventHook, type ClientEventsResponse, type BeforeRetryServerEventHook, type ErrorServerEventHook, type StartServerEventHook, type ServerEvent, type ReceiveEventServerEventHook } from "./types";
 export declare function launchRequestHook(clientHook: readonly RequestHook[], promiseRequestHook: readonly RequestHook[], requestParams: PromiseRequestParams): Promise<PromiseRequestParams>;
 export declare function launchResponseHook(clientHook: readonly ResponseHook[], promiseRequestHook: readonly ResponseHook[], response: ClientResponse): Promise<ClientResponse>;
 export declare function launchInformationHook(clientHook: readonly InformationHook[], promiseRequestHook: readonly InformationHook[], response: ClientResponse): Promise<void>;
@@ -7,3 +7,8 @@ export declare function launchResponseTypeHook(clientHook: readonly ResponseType
 export declare function launchExpectedResponseHook(clientHook: readonly ResponseTypeHook[], promiseRequestHook: readonly ResponseTypeHook[], response: ClientResponse): Promise<void>;
 export declare function launchNotPredictedHook(clientHook: readonly NotPredictedResponseHook[], promiseRequestHook: readonly NotPredictedResponseHook[], response: NotPredictedClientResponse): Promise<void>;
 export declare function launchErrorHook(clientHook: readonly ErrorHook[], promiseRequestHook: readonly ErrorHook[], error: unknown, requestParams: PromiseRequestParams): Promise<void>;
+export declare function launchCloseServerEventHook(clientHook: readonly CloseServerEventHook[], promiseRequestHook: readonly CloseServerEventHook[], response: ClientEventsResponse): Promise<void>;
+export declare function launchBeforeRetryServerEventHook(clientHook: readonly BeforeRetryServerEventHook[], promiseRequestHook: readonly BeforeRetryServerEventHook[], response: ClientEventsResponse): Promise<void>;
+export declare function launchErrorServerEventHook(clientHook: readonly ErrorServerEventHook[], promiseRequestHook: readonly ErrorServerEventHook[], error: unknown, response: ClientEventsResponse): Promise<void>;
+export declare function launchStartServerEventHook(clientHook: readonly StartServerEventHook[], promiseRequestHook: readonly StartServerEventHook[], response: ClientEventsResponse): Promise<void>;
+export declare function launchReceiveEventServerEventHook(clientHook: readonly ReceiveEventServerEventHook[], promiseRequestHook: readonly ReceiveEventServerEventHook[], event: ServerEvent, response: ClientEventsResponse): Promise<void>;

package/dist/client/hooks.mjs

@@ -66,5 +66,45 @@ async function launchErrorHook(clientHook, promiseRequestHook, error, requestPar
         await clientHook[index](error, requestParams);
     }
 }
+async function launchCloseServerEventHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchBeforeRetryServerEventHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchErrorServerEventHook(clientHook, promiseRequestHook, error, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](error, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](error, response);
+    }
+}
+async function launchStartServerEventHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchReceiveEventServerEventHook(clientHook, promiseRequestHook, event, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](event, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](event, response);
+    }
+}
 
-export { launchCodeHook, launchErrorHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchRequestHook, launchResponseHook, launchResponseTypeHook };
+export { launchBeforeRetryServerEventHook, launchCloseServerEventHook, launchCodeHook, launchErrorHook, launchErrorServerEventHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchReceiveEventServerEventHook, launchRequestHook, launchResponseHook, launchResponseTypeHook, launchStartServerEventHook };

package/dist/client/httpClient.cjs

@@ -40,6 +40,11 @@ function createHttpClient(clientParams) {
         expectedResponse: [],
         error: [],
         notPredictedResponse: [],
+        beforeRetryServerEvent: [],
+        closeServerEvent: [],
+        errorServerEvent: [],
+        receiveEventServerEvent: [],
+        startServerEvent: [],
     }, clientParams.hooks ?? {});
     const config = {
         baseUrl: clientParams.baseUrl,
@@ -102,9 +107,27 @@ function createHttpClient(clientParams) {
         addErrorHook(hook) {
             hooks.error.push(hook);
         },
+        addBeforeRetryServerEventHook(hook) {
+            hooks.beforeRetryServerEvent.push(hook);
+        },
+        addCloseServerEventHook(hook) {
+            hooks.closeServerEvent.push(hook);
+        },
+        addErrorServerEventHook(hook) {
+            hooks.errorServerEvent.push(hook);
+        },
+        addReceiveEventServerEventHook(hook) {
+            hooks.receiveEventServerEvent.push(hook);
+        },
+        addStartServerEventHook(hook) {
+            hooks.startServerEvent.push(hook);
+        },
         request(params) {
             const headers = GG__namespace.reduce(defaultHeaders.entries(), GG__namespace.reduceFrom({}), ({ element, lastValue, next }) => {
-                lastValue[element[0]] = `${element[1]()}`;
+                const value = element[1]();
+                if (value !== undefined) {
+                    lastValue[element[0]] = `${value}`;
+                }
                 return next(lastValue);
             });
             return new promiseRequest.PromiseRequest({
@@ -123,6 +146,7 @@ function createHttpClient(clientParams) {
                 predictedHeaderKey: config.predictedHeaderKey,
                 informationHeaderKey: config.informationHeaderKey,
                 disabledPredicateMode: config.disabledPredictedMode,
+                abortController: params.abortController ?? new AbortController(),
             });
         },
         get: ((path, params) => self.request({

package/dist/client/httpClient.d.ts

@@ -1,9 +1,9 @@
 import { type Kind, type MayBeGetter, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
-import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams, type ClientResponse, type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type NotPredictedResponseHook, type ErrorHook, type GetServerRoutePath } from "./types";
+import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams, type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type NotPredictedResponseHook, type ErrorHook, type GetServerRoutePath, type AllClientResponse, type BeforeRetryServerEventHook, type CloseServerEventHook, type ErrorServerEventHook, type StartServerEventHook, type ReceiveEventServerEventHook } from "./types";
 import { PromiseRequest } from "./promiseRequest";
 export declare const httpClientKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/http-client", unknown>>;
 type MaybeRequestParams<GenericRequestParams extends object> = {} extends GenericRequestParams ? [params?: GenericRequestParams] : [params: GenericRequestParams];
-type HttpClientRequestMethod<GenericServerRoute extends ServerRoute, GenericHookParams extends Record<string, unknown>, GenericMethod extends string> = IsEqual<GenericServerRoute, ServerRoute> extends true ? (path: string, params?: SimplifyTopLevel<Omit<ClientRequestParams<GenericHookParams>, "method" | "path">>) => PromiseRequest<GenericHookParams, ClientResponse<GenericHookParams>> : <GenericPath extends Extract<GenericServerRoute, {
+type HttpClientRequestMethod<GenericServerRoute extends ServerRoute, GenericHookParams extends Record<string, unknown>, GenericMethod extends string> = IsEqual<GenericServerRoute, ServerRoute> extends true ? (path: string, params?: SimplifyTopLevel<Omit<ClientRequestParams<GenericHookParams>, "method" | "path">>) => PromiseRequest<GenericHookParams, AllClientResponse<GenericHookParams>> : <GenericPath extends Extract<GenericServerRoute, {
     method: GenericMethod;
 }>["path"], GenericMatchedPath extends GetServerRoutePath<Extract<GenericServerRoute, {
     method: GenericMethod;
@@ -40,9 +40,14 @@ export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute
     addExpectedResponseHook(hook: ExpectedResponseHook<GenericHookParams>): void;
     addNotPredictedResponseHook(hook: NotPredictedResponseHook<GenericHookParams>): void;
     addErrorHook(hook: ErrorHook<GenericHookParams>): void;
+    addBeforeRetryServerEventHook(hook: BeforeRetryServerEventHook<GenericHookParams>): void;
+    addCloseServerEventHook(hook: CloseServerEventHook<GenericHookParams>): void;
+    addErrorServerEventHook(hook: ErrorServerEventHook<GenericHookParams>): void;
+    addStartServerEventHook(hook: StartServerEventHook<GenericHookParams>): void;
+    addReceiveEventServerEventHook(hook: ReceiveEventServerEventHook<GenericHookParams>): void;
     request<GenericClientRequestParams extends ServerRouteToClientRequestParams<GenericServerRoute, GenericHookParams>, GenericMatchedPath extends GetServerRoutePath<Extract<GenericServerRoute, {
         method: GenericClientRequestParams["method"];
-    }>, GenericClientRequestParams["path"]>>(params: GenericClientRequestParams): PromiseRequest<GenericHookParams, ServerRouteToClientResponse<Extract<GenericServerRoute, {
+    }>, GenericClientRequestParams["path"]>>(params: GenericClientRequestParams): PromiseRequest<GenericHookParams, IsEqual<GenericServerRoute, ServerRoute> extends true ? AllClientResponse<GenericHookParams> : ServerRouteToClientResponse<Extract<GenericServerRoute, {
         method: GenericClientRequestParams["method"];
         path: GenericMatchedPath;
     }>, GenericHookParams>>;

package/dist/client/httpClient.mjs

@@ -18,6 +18,11 @@ function createHttpClient(clientParams) {
         expectedResponse: [],
         error: [],
         notPredictedResponse: [],
+        beforeRetryServerEvent: [],
+        closeServerEvent: [],
+        errorServerEvent: [],
+        receiveEventServerEvent: [],
+        startServerEvent: [],
     }, clientParams.hooks ?? {});
     const config = {
         baseUrl: clientParams.baseUrl,
@@ -80,9 +85,27 @@ function createHttpClient(clientParams) {
         addErrorHook(hook) {
             hooks.error.push(hook);
         },
+        addBeforeRetryServerEventHook(hook) {
+            hooks.beforeRetryServerEvent.push(hook);
+        },
+        addCloseServerEventHook(hook) {
+            hooks.closeServerEvent.push(hook);
+        },
+        addErrorServerEventHook(hook) {
+            hooks.errorServerEvent.push(hook);
+        },
+        addReceiveEventServerEventHook(hook) {
+            hooks.receiveEventServerEvent.push(hook);
+        },
+        addStartServerEventHook(hook) {
+            hooks.startServerEvent.push(hook);
+        },
         request(params) {
             const headers = GG.reduce(defaultHeaders.entries(), GG.reduceFrom({}), ({ element, lastValue, next }) => {
-                lastValue[element[0]] = `${element[1]()}`;
+                const value = element[1]();
+                if (value !== undefined) {
+                    lastValue[element[0]] = `${value}`;
+                }
                 return next(lastValue);
             });
             return new PromiseRequest({
@@ -101,6 +124,7 @@ function createHttpClient(clientParams) {
                 predictedHeaderKey: config.predictedHeaderKey,
                 informationHeaderKey: config.informationHeaderKey,
                 disabledPredicateMode: config.disabledPredictedMode,
+                abortController: params.abortController ?? new AbortController(),
             });
         },
         get: ((path, params) => self.request({

package/dist/client/index.cjs

@@ -9,20 +9,26 @@ var insertParamsInPath = require('./insertParamsInPath.cjs');
 var queryToString = require('./queryToString.cjs');
 var promiseRequest = require('./promiseRequest.cjs');
 var unexpectedResponseError = require('./unexpectedResponseError.cjs');
+var serverSentEvents = require('./serverSentEvents.cjs');
 
 
 
 exports.createClientKind = kind.createClientKind;
 exports.createHttpClient = httpClient.createHttpClient;
 exports.httpClientKind = httpClient.httpClientKind;
+exports.launchBeforeRetryServerEventHook = hooks.launchBeforeRetryServerEventHook;
+exports.launchCloseServerEventHook = hooks.launchCloseServerEventHook;
 exports.launchCodeHook = hooks.launchCodeHook;
 exports.launchErrorHook = hooks.launchErrorHook;
+exports.launchErrorServerEventHook = hooks.launchErrorServerEventHook;
 exports.launchExpectedResponseHook = hooks.launchExpectedResponseHook;
 exports.launchInformationHook = hooks.launchInformationHook;
 exports.launchNotPredictedHook = hooks.launchNotPredictedHook;
+exports.launchReceiveEventServerEventHook = hooks.launchReceiveEventServerEventHook;
 exports.launchRequestHook = hooks.launchRequestHook;
 exports.launchResponseHook = hooks.launchResponseHook;
 exports.launchResponseTypeHook = hooks.launchResponseTypeHook;
+exports.launchStartServerEventHook = hooks.launchStartServerEventHook;
 exports.getBody = getBody.getBody;
 exports.insertParamsInPath = insertParamsInPath.insertParamsInPath;
 exports.queryToString = queryToString.queryToString;
@@ -31,3 +37,4 @@ exports.UnexpectedCodeResponseError = unexpectedResponseError.UnexpectedCodeResp
 exports.UnexpectedInformationResponseError = unexpectedResponseError.UnexpectedInformationResponseError;
 exports.UnexpectedResponseError = unexpectedResponseError.UnexpectedResponseError;
 exports.UnexpectedResponseTypeError = unexpectedResponseError.UnexpectedResponseTypeError;
+exports.makeClientEventsResponse = serverSentEvents.makeClientEventsResponse;

package/dist/client/index.d.ts

@@ -7,3 +7,4 @@ export * from "./insertParamsInPath";
 export * from "./queryToString";
 export * from "./promiseRequest";
 export * from "./unexpectedResponseError";
+export * from "./serverSentEvents";

package/dist/client/index.mjs

@@ -1,9 +1,10 @@
 import './types/index.mjs';
 export { createClientKind } from './kind.mjs';
 export { createHttpClient, httpClientKind } from './httpClient.mjs';
-export { launchCodeHook, launchErrorHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchRequestHook, launchResponseHook, launchResponseTypeHook } from './hooks.mjs';
+export { launchBeforeRetryServerEventHook, launchCloseServerEventHook, launchCodeHook, launchErrorHook, launchErrorServerEventHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchReceiveEventServerEventHook, launchRequestHook, launchResponseHook, launchResponseTypeHook, launchStartServerEventHook } from './hooks.mjs';
 export { getBody } from './getBody.mjs';
 export { insertParamsInPath } from './insertParamsInPath.mjs';
 export { queryToString } from './queryToString.mjs';
 export { PromiseRequest } from './promiseRequest.mjs';
 export { UnexpectedCodeResponseError, UnexpectedInformationResponseError, UnexpectedResponseError, UnexpectedResponseTypeError } from './unexpectedResponseError.mjs';
+export { makeClientEventsResponse } from './serverSentEvents.mjs';

package/dist/client/insertParamsInPath.cjs

@@ -4,7 +4,7 @@ function insertParamsInPath(path, params) {
     if (!params) {
         return path;
     }
-    return Object.entries(params).reduce((pv, [key, value]) => value
+    return Object.entries(params).reduce((pv, [key, value]) => value !== undefined
         ? pv.replace(`{${key}}`, value.toString())
         : pv, path);
 }

package/dist/client/insertParamsInPath.mjs

@@ -2,7 +2,7 @@ function insertParamsInPath(path, params) {
     if (!params) {
         return path;
     }
-    return Object.entries(params).reduce((pv, [key, value]) => value
+    return Object.entries(params).reduce((pv, [key, value]) => value !== undefined
         ? pv.replace(`{${key}}`, value.toString())
         : pv, path);
 }

package/dist/client/promiseRequest.cjs

@@ -9,6 +9,7 @@ var EE = require('@duplojs/utils/either');
 var SS = require('@duplojs/utils/string');
 var AA = require('@duplojs/utils/array');
 var unexpectedResponseError = require('./unexpectedResponseError.cjs');
+var serverSentEvents = require('./serverSentEvents.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -65,7 +66,7 @@ class PromiseRequest extends Promise {
             return EE__namespace.right("response", response);
         })
             .then(async (result) => {
-            if (EE__namespace.eitherFutureErrorKind.has(result)) {
+            if (EE__namespace.futureErrorKind.has(result)) {
                 const error = utils.unwrap(result);
                 await hooks.launchErrorHook(params.hooks.error, this.hooks.error ?? [], error, params);
                 return EE__namespace.left("request-error", {
@@ -146,10 +147,22 @@ class PromiseRequest extends Promise {
         this.hooks.error.push(callback);
         return this;
     }
+    whenReceiveServerEvent(eventName, callback) {
+        void this.then(EE__namespace.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__namespace.coalescing(information);
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (response.information !== undefined
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && response.information !== undefined
                 && AA__namespace.includes(formattedInformation, response.information)) {
                 return EE__namespace.right("response", response);
             }
@@ -159,7 +172,9 @@ class PromiseRequest extends Promise {
     iWantCode(code) {
         const formattedCode = AA__namespace.coalescing(code);
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (AA__namespace.includes(formattedCode, response.code)) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && AA__namespace.includes(formattedCode, response.code)) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -167,7 +182,9 @@ class PromiseRequest extends Promise {
     }
     iWantInformationalResponse() {
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (SS__namespace.startsWith(response.code, "1")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS__namespace.startsWith(response.code, "1")) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -175,7 +192,9 @@ class PromiseRequest extends Promise {
     }
     iWantSuccessfulResponse() {
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (SS__namespace.startsWith(response.code, "2")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS__namespace.startsWith(response.code, "2")) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -183,7 +202,9 @@ class PromiseRequest extends Promise {
     }
     iWantRedirectionResponse() {
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (SS__namespace.startsWith(response.code, "3")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS__namespace.startsWith(response.code, "3")) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -191,7 +212,9 @@ class PromiseRequest extends Promise {
     }
     iWantClientErrorResponse() {
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (SS__namespace.startsWith(response.code, "4")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS__namespace.startsWith(response.code, "4")) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -199,7 +222,9 @@ class PromiseRequest extends Promise {
     }
     iWantServerErrorResponse() {
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (SS__namespace.startsWith(response.code, "5")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && SS__namespace.startsWith(response.code, "5")) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -207,7 +232,20 @@ class PromiseRequest extends Promise {
     }
     iWantExpectedResponse() {
         return this.then(EE__namespace.whenIsRight((response) => {
-            if (SS__namespace.startsWith(response.code, "2") || SS__namespace.startsWith(response.code, "4")) {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && (SS__namespace.startsWith(response.code, "2")
+                    || SS__namespace.startsWith(response.code, "4"))) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iSelectExpectedResponseByInformation(selector) {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && selector[(response.information ?? "")] === true) {
                 return EE__namespace.right("response", response);
             }
             return EE__namespace.left("unexpect-response", response);
@@ -293,6 +331,16 @@ class PromiseRequest extends Promise {
             throw new unexpectedResponseError.UnexpectedResponseError(utils.unwrap(maybeResponse));
         });
     }
+    iSelectExpectedResponseByInformationOrThrow(selector) {
+        return this
+            .iSelectExpectedResponseByInformation(selector)
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseError(utils.unwrap(maybeResponse));
+        });
+    }
     static get [Symbol.species]() {
         return Promise;
     }
@@ -326,28 +374,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.getBody(response)
-            .then((body) => EE__namespace.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__namespace.right("response", serverSentEvents.makeClientEventsResponse(clientResponse, fetchUrl, fetchInitParams));
+            }
+            return EE__namespace.right("response", clientResponse);
+        }))
             .catch((error) => EE__namespace.left("request-error", {
             error,
             requestParams,