@duplojs/http 0.2.0 → 0.4.0

package/dist/client/promiseRequest.mjs

@@ -0,0 +1,332 @@
+import { unwrap } from '@duplojs/utils';
+import { getBody } from './getBody.mjs';
+import { insertParamsInPath } from './insertParamsInPath.mjs';
+import { queryToString } from './queryToString.mjs';
+import { launchRequestHook, launchResponseHook, launchNotPredictedHook, launchResponseTypeHook, launchExpectedResponseHook, launchInformationHook, launchCodeHook, launchErrorHook } from './hooks.mjs';
+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';
+
+class PromiseRequest extends Promise {
+    params;
+    hooks = {};
+    constructor(params) {
+        super((resolve) => void EE
+            .rightAsyncPipe(Promise.resolve(params), (params) => launchRequestHook(params.hooks.request, this.hooks.request ?? [], params), PromiseRequest.fetch, (response) => launchResponseHook(params.hooks.response, this.hooks.response ?? [], response), async (response) => {
+            if (params.disabledPredicateMode === false && response.predicted === false) {
+                await launchNotPredictedHook(params.hooks.notPredictedResponse, this.hooks.notPredictedResponse ?? [], response);
+                return EE.right("response", response);
+            }
+            if (SS.startsWith(response.code, "1")) {
+                await launchResponseTypeHook(params.hooks.informationalResponseType, this.hooks.informationalResponseType ?? [], response);
+            }
+            else if (SS.startsWith(response.code, "2")) {
+                await launchResponseTypeHook(params.hooks.successfulResponseType, this.hooks.successfulResponseType ?? [], response);
+                await launchExpectedResponseHook(params.hooks.expectedResponse, this.hooks.expectedResponse ?? [], response);
+            }
+            else if (SS.startsWith(response.code, "3")) {
+                await launchResponseTypeHook(params.hooks.redirectionResponseType, this.hooks.redirectionResponseType ?? [], response);
+            }
+            else if (SS.startsWith(response.code, "4")) {
+                await launchResponseTypeHook(params.hooks.clientErrorResponseType, this.hooks.clientErrorResponseType ?? [], response);
+                await launchExpectedResponseHook(params.hooks.expectedResponse, this.hooks.expectedResponse ?? [], response);
+            }
+            else if (SS.startsWith(response.code, "5")) {
+                await launchResponseTypeHook(params.hooks.serverErrorResponseType, this.hooks.serverErrorResponseType ?? [], response);
+            }
+            if (response.information !== undefined) {
+                await launchInformationHook(params.hooks.information[response.information] ?? [], this.hooks.information?.[response.information] ?? [], response);
+            }
+            await launchCodeHook(params.hooks.code[response.code] ?? [], this.hooks.code?.[response.code] ?? [], response);
+            return EE.right("response", response);
+        })
+            .then(async (result) => {
+            if (EE.eitherFutureErrorKind.has(result)) {
+                const error = unwrap(result);
+                await launchErrorHook(params.hooks.error, this.hooks.error ?? [], error, params);
+                return EE.left("request-error", {
+                    error,
+                    requestParams: params,
+                });
+            }
+            return result;
+        })
+            .then(resolve));
+        this.params = params;
+    }
+    addRequestInterceptor(callback) {
+        this.hooks.request ??= [];
+        this.hooks.request.push(callback);
+        return this;
+    }
+    addResponseInterceptor(callback) {
+        this.hooks.response ??= [];
+        this.hooks.response.push(callback);
+        return this;
+    }
+    whenNotPredictedResponse(callback) {
+        this.hooks.notPredictedResponse ??= [];
+        this.hooks.notPredictedResponse.push(callback);
+        return this;
+    }
+    whenInformation(information, callback) {
+        const formattedInformation = AA.coalescing(information);
+        formattedInformation.forEach((information) => {
+            this.hooks.information ??= {};
+            this.hooks.information[information] ??= [];
+            this.hooks.information[information].push(callback);
+        });
+        return this;
+    }
+    whenCode(code, callback) {
+        const formattedCode = AA.coalescing(code);
+        formattedCode.forEach((code) => {
+            this.hooks.code ??= {};
+            this.hooks.code[code] ??= [];
+            this.hooks.code[code].push(callback);
+        });
+        return this;
+    }
+    whenInformationalResponse(callback) {
+        this.hooks.informationalResponseType ??= [];
+        this.hooks.informationalResponseType.push(callback);
+        return this;
+    }
+    whenSuccessfulResponse(callback) {
+        this.hooks.successfulResponseType ??= [];
+        this.hooks.successfulResponseType.push(callback);
+        return this;
+    }
+    whenRedirectionResponse(callback) {
+        this.hooks.redirectionResponseType ??= [];
+        this.hooks.redirectionResponseType.push(callback);
+        return this;
+    }
+    whenClientErrorResponse(callback) {
+        this.hooks.clientErrorResponseType ??= [];
+        this.hooks.clientErrorResponseType.push(callback);
+        return this;
+    }
+    whenServerErrorResponse(callback) {
+        this.hooks.serverErrorResponseType ??= [];
+        this.hooks.serverErrorResponseType.push(callback);
+        return this;
+    }
+    whenExpectedResponse(callback) {
+        this.hooks.expectedResponse ??= [];
+        this.hooks.expectedResponse.push(callback);
+        return this;
+    }
+    whenError(callback) {
+        this.hooks.error ??= [];
+        this.hooks.error.push(callback);
+        return this;
+    }
+    iWantInformation(information) {
+        const formattedInformation = AA.coalescing(information);
+        return this.then(EE.whenIsRight((response) => {
+            if (response.information !== undefined
+                && AA.includes(formattedInformation, response.information)) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantCode(code) {
+        const formattedCode = AA.coalescing(code);
+        return this.then(EE.whenIsRight((response) => {
+            if (AA.includes(formattedCode, response.code)) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantInformationalResponse() {
+        return this.then(EE.whenIsRight((response) => {
+            if (SS.startsWith(response.code, "1")) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantSuccessfulResponse() {
+        return this.then(EE.whenIsRight((response) => {
+            if (SS.startsWith(response.code, "2")) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantRedirectionResponse() {
+        return this.then(EE.whenIsRight((response) => {
+            if (SS.startsWith(response.code, "3")) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantClientErrorResponse() {
+        return this.then(EE.whenIsRight((response) => {
+            if (SS.startsWith(response.code, "4")) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantServerErrorResponse() {
+        return this.then(EE.whenIsRight((response) => {
+            if (SS.startsWith(response.code, "5")) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantExpectedResponse() {
+        return this.then(EE.whenIsRight((response) => {
+            if (SS.startsWith(response.code, "2") || SS.startsWith(response.code, "4")) {
+                return EE.right("response", response);
+            }
+            return EE.left("unexpect-response", response);
+        }));
+    }
+    iWantInformationOrThrow(information) {
+        return this
+            .iWantInformation(information)
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedInformationResponseError(information, unwrap(maybeResponse));
+        });
+    }
+    iWantCodeOrThrow(code) {
+        return this
+            .iWantCode(code)
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedCodeResponseError(code, unwrap(maybeResponse));
+        });
+    }
+    iWantInformationalResponseOrThrow() {
+        return this
+            .iWantInformationalResponse()
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseTypeError("informational", unwrap(maybeResponse));
+        });
+    }
+    iWantSuccessfulResponseOrThrow() {
+        return this
+            .iWantSuccessfulResponse()
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseTypeError("successful", unwrap(maybeResponse));
+        });
+    }
+    iWantRedirectionResponseOrThrow() {
+        return this
+            .iWantRedirectionResponse()
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseTypeError("redirection", unwrap(maybeResponse));
+        });
+    }
+    iWantClientErrorResponseOrThrow() {
+        return this
+            .iWantClientErrorResponse()
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseTypeError("clientError", unwrap(maybeResponse));
+        });
+    }
+    iWantServerErrorResponseOrThrow() {
+        return this
+            .iWantServerErrorResponse()
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseTypeError("informational", unwrap(maybeResponse));
+        });
+    }
+    iWantExpectedResponseOrThrow() {
+        return this
+            .iWantExpectedResponse()
+            .then((maybeResponse) => {
+            if (EE.isRight(maybeResponse)) {
+                return unwrap(maybeResponse);
+            }
+            throw new UnexpectedResponseError(unwrap(maybeResponse));
+        });
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    static fetch(requestParams) {
+        const path = insertParamsInPath(requestParams.path, requestParams.params);
+        const query = queryToString(requestParams.query);
+        const url = query
+            ? `${path}?${query}`
+            : path;
+        const headers = { ...requestParams.headers };
+        let body = requestParams.body;
+        if (body) {
+            if (!headers["content-type"]) {
+                if (typeof body === "string") {
+                    headers["content-type"] = "text/plain; charset=utf-8";
+                    body = body.toString();
+                }
+                else if ((body
+                    && typeof body === "object"
+                    && body?.constructor?.name === "Object")
+                    || (body instanceof Array
+                        && body?.constructor?.name === "Array")
+                    || body === null
+                    || typeof body === "boolean"
+                    || typeof body === "number") {
+                    headers["content-type"] = "application/json; charset=utf-8";
+                    body = JSON.stringify(body);
+                }
+            }
+        }
+        return fetch(`${requestParams.baseUrl}${url}`, {
+            ...requestParams.initParams,
+            headers: headers,
+            method: requestParams.method,
+            body: body,
+        })
+            .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,
+        })))
+            .catch((error) => EE.left("request-error", {
+            error,
+            requestParams,
+        }));
+    }
+}
+
+export { PromiseRequest };

package/dist/client/queryToString.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+function queryToString(query) {
+    if (!query) {
+        return null;
+    }
+    return Object.entries(query)
+        .reduce((pv, [key, value]) => {
+        if (!value) {
+            return pv;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((subValue) => {
+                pv.push(`${key}=${subValue}`);
+            });
+        }
+        else {
+            pv.push(`${key}=${value}`);
+        }
+        return pv;
+    }, [])
+        .join("&") || null;
+}
+
+exports.queryToString = queryToString;

package/dist/client/queryToString.d.ts

@@ -0,0 +1,2 @@
+import { type ClientRequestParams } from "./types";
+export declare function queryToString(query: ClientRequestParams["query"]): string | null;

package/dist/client/queryToString.mjs

@@ -0,0 +1,23 @@
+function queryToString(query) {
+    if (!query) {
+        return null;
+    }
+    return Object.entries(query)
+        .reduce((pv, [key, value]) => {
+        if (!value) {
+            return pv;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((subValue) => {
+                pv.push(`${key}=${subValue}`);
+            });
+        }
+        else {
+            pv.push(`${key}=${value}`);
+        }
+        return pv;
+    }, [])
+        .join("&") || null;
+}
+
+export { queryToString };

package/dist/client/types/ObjectCanBeEmpty.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,4 @@
+import { type IsEqual } from "@duplojs/utils";
+export type ObjectCanBeEmpty<GenericObject extends object> = IsEqual<{
+    [Prop in keyof GenericObject]-?: undefined extends GenericObject[Prop] ? true : false;
+}[keyof GenericObject], true>;

package/dist/client/types/ObjectCanBeEmpty.mjs

@@ -0,0 +1 @@
+

package/dist/client/types/clientRequestParams.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,51 @@
+import { type SimplifyTopLevel, type IsEqual, type MaybeArray, type AnyTuple } from "@duplojs/utils";
+import { type ServerRouteHeaders, type ServerRouteParams, type ServerRouteQuery, type ServerRoute, type ServerPrimitiveData } from "./serverRoute";
+import { type ObjectCanBeEmpty } from "./ObjectCanBeEmpty";
+import type * as OO from "@duplojs/utils/object";
+export interface ClientRequestInitParams extends Pick<RequestInit, "cache" | "credentials" | "integrity" | "keepalive" | "mode" | "redirect" | "referrer" | "referrerPolicy" | "signal"> {
+}
+export type ClientRequestParamsHeaders = Record<string, string | undefined>;
+export type ClientRequestParamsParams = Record<string, string | undefined>;
+export type ClientRequestParamsQuery = Record<string, MaybeArray<string> | undefined>;
+export type ClientRequestParamsBody = unknown;
+export interface ClientRequestParams<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> {
+    method: string;
+    path: string;
+    headers?: ClientRequestParamsHeaders;
+    params?: ClientRequestParamsParams;
+    query?: ClientRequestParamsQuery;
+    body?: ClientRequestParamsBody;
+    initParams?: ClientRequestInitParams;
+    hookParams?: GenericHookParams;
+}
+type StringifyTuple<GenericTuple extends AnyTuple<ServerPrimitiveData>> = GenericTuple extends [
+    infer InferredFirst extends ServerPrimitiveData,
+    ...infer InferredRest
+] ? InferredRest extends readonly [] ? [`${InferredFirst}`] : InferredRest extends AnyTuple ? StringifyTuple<InferredRest> extends infer InferredResult extends AnyTuple ? [`${InferredFirst}`, ...InferredResult] : never : never : never;
+export type ServerRouteToClientRequestParamsHeaders<GenericHeader extends ServerRouteHeaders | undefined> = GenericHeader extends ServerRouteHeaders ? SimplifyTopLevel<{
+    [Prop in keyof GenericHeader]: GenericHeader[Prop] extends infer InferredValue ? InferredValue extends ServerPrimitiveData ? InferredValue extends undefined ? InferredValue : `${InferredValue}` : never : never;
+}> : GenericHeader;
+export type ServerRouteToClientRequestParamsParams<GenericParams extends ServerRouteParams | undefined> = GenericParams extends ServerRouteParams ? SimplifyTopLevel<{
+    [Prop in keyof GenericParams]: GenericParams[Prop] extends infer InferredValue ? InferredValue extends ServerPrimitiveData ? InferredValue extends undefined ? InferredValue : `${InferredValue}` : never : never;
+}> : GenericParams;
+export type ServerRouteToClientRequestParamsQuery<GenericQuery extends ServerRouteQuery | undefined> = GenericQuery extends ServerRouteQuery ? SimplifyTopLevel<{
+    [Prop in keyof GenericQuery]: GenericQuery[Prop] extends infer InferredValue ? InferredValue extends MaybeArray<ServerPrimitiveData> ? InferredValue extends undefined ? InferredValue : InferredValue extends AnyTuple ? StringifyTuple<InferredValue> : InferredValue extends readonly any[] ? `${InferredValue[number]}`[] : InferredValue extends ServerPrimitiveData ? `${InferredValue}` : never : never : never;
+}> : GenericQuery;
+type MaybeParams<GenericParams extends object> = {
+    [Prop in keyof GenericParams]-?: undefined extends GenericParams[Prop] ? Prop : GenericParams[Prop] extends object ? ObjectCanBeEmpty<GenericParams[Prop]> extends true ? Prop : never : never;
+}[keyof GenericParams] extends infer InferredKeys extends keyof GenericParams ? OO.PartialKeys<GenericParams, InferredKeys> : never;
+export type ServerRouteToClientRequestParams<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = GenericServerRoute extends any ? SimplifyTopLevel<({
+    method: GenericServerRoute["method"];
+    path: GenericServerRoute["path"];
+    initParams?: ClientRequestInitParams;
+    hookParams?: GenericHookParams;
+} & MaybeParams<(IsEqual<GenericServerRoute["headers"], unknown> extends true ? {} : {
+    headers: ServerRouteToClientRequestParamsHeaders<GenericServerRoute["headers"]>;
+}) & (IsEqual<GenericServerRoute["params"], unknown> extends true ? {} : {
+    params: ServerRouteToClientRequestParamsParams<GenericServerRoute["params"]>;
+}) & (IsEqual<GenericServerRoute["query"], unknown> extends true ? {} : {
+    query: ServerRouteToClientRequestParamsQuery<GenericServerRoute["query"]>;
+}) & (IsEqual<GenericServerRoute["body"], unknown> extends true ? {} : {
+    body: GenericServerRoute["body"];
+})>)> extends infer InferredResult extends ClientRequestParams ? InferredResult : never : never;
+export {};

package/dist/client/types/clientRequestParams.mjs

@@ -0,0 +1 @@
+

package/dist/client/types/clientResponse.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,34 @@
+import type * as SS from "@duplojs/utils/string";
+import { type ServerRouteResponse, type ServerRoute } from "./serverRoute";
+import { type IsEqual, type SimplifyTopLevel } from "@duplojs/utils";
+import { type PromiseRequestParams } from "../promiseRequest";
+export type ClientResponseBody = unknown;
+export interface ClientResponse<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> {
+    code: SS.Number;
+    information: undefined | string;
+    body: ClientResponseBody;
+    ok: boolean | null;
+    headers: Headers;
+    type: ResponseType;
+    url: string;
+    redirected: boolean;
+    raw: globalThis.Response;
+    requestParams: GenericPromiseRequestParams;
+    predicted: boolean;
+}
+export interface NotPredictedClientResponse<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> extends ClientResponse<GenericPromiseRequestParams> {
+    predicted: false;
+}
+export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = IsEqual<GenericServerRoute, ServerRoute> extends true ? ClientResponse<PromiseRequestParams<GenericHookParams>> : GenericServerRoute extends any ? GenericServerRoute["responses"] extends infer InferredResponse ? InferredResponse extends ServerRouteResponse ? SimplifyTopLevel<{
+    code: InferredResponse["code"];
+    information: InferredResponse["information"];
+    body: InferredResponse["body"];
+    ok: boolean | null;
+    headers: Headers;
+    type: ResponseType;
+    url: string;
+    redirected: boolean;
+    raw: globalThis.Response;
+    requestParams: PromiseRequestParams<GenericHookParams>;
+    predicted: boolean;
+}> extends infer InferredResult extends ClientResponse ? InferredResult : never : never : never : never;

package/dist/client/types/clientResponse.mjs

@@ -0,0 +1 @@
+

package/dist/client/types/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+require('./clientRequestParams.cjs');
+require('./clientResponse.cjs');
+require('./serverRoute.cjs');
+require('./ObjectCanBeEmpty.cjs');
+

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

@@ -0,0 +1,4 @@
+export * from "./clientRequestParams";
+export * from "./clientResponse";
+export * from "./serverRoute";
+export * from "./ObjectCanBeEmpty";

package/dist/client/types/index.mjs

@@ -0,0 +1,4 @@
+import './clientRequestParams.mjs';
+import './clientResponse.mjs';
+import './serverRoute.mjs';
+import './ObjectCanBeEmpty.mjs';

package/dist/client/types/serverRoute.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,22 @@
+import { type MaybeArray } from "@duplojs/utils";
+import type * as SS from "@duplojs/utils/string";
+export type ServerPrimitiveData = string | undefined | number | null | boolean;
+export type ServerRouteHeaders = Record<string, ServerPrimitiveData>;
+export type ServerRouteParams = Record<string, ServerPrimitiveData>;
+export type ServerRouteQuery = Record<string, MaybeArray<ServerPrimitiveData>>;
+export type ServerRouteBody = unknown;
+export type ServerRouteResponseBody = unknown;
+export interface ServerRouteResponse {
+    code: SS.Number;
+    information?: string;
+    body?: ServerRouteResponseBody;
+}
+export interface ServerRoute {
+    path: string;
+    method: string;
+    headers?: ServerRouteHeaders;
+    params?: ServerRouteParams;
+    query?: ServerRouteQuery;
+    body?: ServerRouteBody;
+    responses: ServerRouteResponse;
+}

package/dist/client/types/serverRoute.mjs

@@ -0,0 +1 @@
+

package/dist/client/unexpectedResponseError.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('./kind.cjs');
+
+class UnexpectedInformationResponseError extends utils.kindHeritage("unexpected-information-response-error", kind.createClientKind("unexpected-information-response-error"), Error) {
+    information;
+    response;
+    constructor(information, response) {
+        super({}, ["Unexpected information response."]);
+        this.information = information;
+        this.response = response;
+    }
+}
+class UnexpectedCodeResponseError extends utils.kindHeritage("unexpected-code-response-error", kind.createClientKind("unexpected-code-response-error"), Error) {
+    code;
+    response;
+    constructor(code, response) {
+        super({}, ["Unexpected code response."]);
+        this.code = code;
+        this.response = response;
+    }
+}
+class UnexpectedResponseTypeError extends utils.kindHeritage("unexpected-response-type-error", kind.createClientKind("unexpected-response-type-error"), Error) {
+    expectType;
+    response;
+    constructor(expectType, response) {
+        super({}, ["Unexpected response type."]);
+        this.expectType = expectType;
+        this.response = response;
+    }
+}
+class UnexpectedResponseError extends utils.kindHeritage("unexpected-response-error", kind.createClientKind("unexpected-response-error"), Error) {
+    response;
+    constructor(response) {
+        super({}, ["Unexpected response."]);
+        this.response = response;
+    }
+}
+
+exports.UnexpectedCodeResponseError = UnexpectedCodeResponseError;
+exports.UnexpectedInformationResponseError = UnexpectedInformationResponseError;
+exports.UnexpectedResponseError = UnexpectedResponseError;
+exports.UnexpectedResponseTypeError = UnexpectedResponseTypeError;

package/dist/client/unexpectedResponseError.d.ts

@@ -0,0 +1,38 @@
+import { type ClientResponse } from "./types";
+import { type PromiseRequestParams } from "./promiseRequest";
+export interface RequestErrorContent {
+    error: unknown;
+    requestParams: PromiseRequestParams;
+}
+declare const UnexpectedInformationResponseError_base: new (params: {
+    "@DuplojsHttpClient/unexpected-information-response-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
+export declare class UnexpectedInformationResponseError extends UnexpectedInformationResponseError_base {
+    information: string | string[];
+    response: RequestErrorContent | ClientResponse;
+    constructor(information: string | string[], response: RequestErrorContent | ClientResponse);
+}
+declare const UnexpectedCodeResponseError_base: new (params: {
+    "@DuplojsHttpClient/unexpected-code-response-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
+export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseError_base {
+    code: string | string[];
+    response: RequestErrorContent | ClientResponse;
+    constructor(code: string | string[], response: RequestErrorContent | ClientResponse);
+}
+declare const UnexpectedResponseTypeError_base: new (params: {
+    "@DuplojsHttpClient/unexpected-response-type-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
+export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeError_base {
+    expectType: "informational" | "successful" | "redirection" | "clientError" | "serverError";
+    response: RequestErrorContent | ClientResponse;
+    constructor(expectType: "informational" | "successful" | "redirection" | "clientError" | "serverError", response: RequestErrorContent | ClientResponse);
+}
+declare const UnexpectedResponseError_base: new (params: {
+    "@DuplojsHttpClient/unexpected-response-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
+export declare class UnexpectedResponseError extends UnexpectedResponseError_base {
+    response: RequestErrorContent | ClientResponse;
+    constructor(response: RequestErrorContent | ClientResponse);
+}
+export {};