@duplojs/http 0.1.0 → 0.4.0

package/dist/client/getBody.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+function getBody(response) {
+    const responseContentType = response.headers.get("content-type") ?? undefined;
+    if (!responseContentType) {
+        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 response.blob();
+    }
+}
+
+exports.getBody = getBody;

package/dist/client/getBody.d.ts

@@ -0,0 +1 @@
+export declare function getBody(response: Response): Promise<unknown>;

package/dist/client/getBody.mjs

@@ -0,0 +1,20 @@
+function getBody(response) {
+    const responseContentType = response.headers.get("content-type") ?? undefined;
+    if (!responseContentType) {
+        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 response.blob();
+    }
+}
+
+export { getBody };

package/dist/client/hooks.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+async function launchRequestHook(clientHook, promiseRequestHook, requestParams) {
+    let resultRequestParams = requestParams;
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        resultRequestParams = await promiseRequestHook[index](resultRequestParams);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        resultRequestParams = await clientHook[index](resultRequestParams);
+    }
+    return resultRequestParams;
+}
+async function launchResponseHook(clientHook, promiseRequestHook, response) {
+    let resultResponse = response;
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        resultResponse = await promiseRequestHook[index](resultResponse);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        resultResponse = await clientHook[index](resultResponse);
+    }
+    return resultResponse;
+}
+async function launchInformationHook(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 launchCodeHook(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 launchResponseTypeHook(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 launchExpectedResponseHook(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 launchNotPredictedHook(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 launchErrorHook(clientHook, promiseRequestHook, error, requestParams) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](error, requestParams);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](error, requestParams);
+    }
+}
+
+exports.launchCodeHook = launchCodeHook;
+exports.launchErrorHook = launchErrorHook;
+exports.launchExpectedResponseHook = launchExpectedResponseHook;
+exports.launchInformationHook = launchInformationHook;
+exports.launchNotPredictedHook = launchNotPredictedHook;
+exports.launchRequestHook = launchRequestHook;
+exports.launchResponseHook = launchResponseHook;
+exports.launchResponseTypeHook = launchResponseTypeHook;

package/dist/client/hooks.d.ts

@@ -0,0 +1,33 @@
+import { type MaybePromise } from "@duplojs/utils";
+import { type NotPredictedClientResponse, type ClientResponse } from "./types/clientResponse";
+import { type PromiseRequestParams } from "./promiseRequest";
+export type RequestHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (requestParams: GenericPromiseRequestParams) => MaybePromise<PromiseRequestParams>;
+export type ResponseHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<ClientResponse<GenericPromiseRequestParams>>;
+export type InformationHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
+export type ResponseTypeHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
+export type ExpectedResponseHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
+export type CodeHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
+export type NotPredictedResponseHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: NotPredictedClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
+export type ErrorHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (error: unknown, requestParams: GenericPromiseRequestParams) => MaybePromise<void>;
+export interface Hooks {
+    request: RequestHook[];
+    response: ResponseHook[];
+    information: Record<string, InformationHook[]>;
+    code: Record<string, CodeHook[]>;
+    informationalResponseType: ResponseTypeHook[];
+    successfulResponseType: ResponseTypeHook[];
+    redirectionResponseType: ResponseTypeHook[];
+    clientErrorResponseType: ResponseTypeHook[];
+    serverErrorResponseType: ResponseTypeHook[];
+    expectedResponse: ExpectedResponseHook[];
+    notPredictedResponse: NotPredictedResponseHook[];
+    error: ErrorHook[];
+}
+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>;
+export declare function launchCodeHook(clientHook: readonly CodeHook[], promiseRequestHook: readonly CodeHook[], response: ClientResponse): Promise<void>;
+export declare function launchResponseTypeHook(clientHook: readonly ResponseTypeHook[], promiseRequestHook: readonly ResponseTypeHook[], response: ClientResponse): Promise<void>;
+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>;

package/dist/client/hooks.mjs

@@ -0,0 +1,70 @@
+async function launchRequestHook(clientHook, promiseRequestHook, requestParams) {
+    let resultRequestParams = requestParams;
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        resultRequestParams = await promiseRequestHook[index](resultRequestParams);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        resultRequestParams = await clientHook[index](resultRequestParams);
+    }
+    return resultRequestParams;
+}
+async function launchResponseHook(clientHook, promiseRequestHook, response) {
+    let resultResponse = response;
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        resultResponse = await promiseRequestHook[index](resultResponse);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        resultResponse = await clientHook[index](resultResponse);
+    }
+    return resultResponse;
+}
+async function launchInformationHook(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 launchCodeHook(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 launchResponseTypeHook(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 launchExpectedResponseHook(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 launchNotPredictedHook(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 launchErrorHook(clientHook, promiseRequestHook, error, requestParams) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](error, requestParams);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](error, requestParams);
+    }
+}
+
+export { launchCodeHook, launchErrorHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchRequestHook, launchResponseHook, launchResponseTypeHook };

package/dist/client/httpClient.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+var OO = require('@duplojs/utils/object');
+var GG = require('@duplojs/utils/generator');
+var kind = require('./kind.cjs');
+var promiseRequest = require('./promiseRequest.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 OO__namespace = /*#__PURE__*/_interopNamespaceDefault(OO);
+var GG__namespace = /*#__PURE__*/_interopNamespaceDefault(GG);
+
+const httpClientKind = kind.createClientKind("http-client");
+function createHttpClient(clientParams) {
+    const hooks = OO__namespace.override({
+        request: [],
+        response: [],
+        information: {},
+        code: {},
+        informationalResponseType: [],
+        successfulResponseType: [],
+        redirectionResponseType: [],
+        clientErrorResponseType: [],
+        serverErrorResponseType: [],
+        expectedResponse: [],
+        error: [],
+        notPredictedResponse: [],
+    }, clientParams.hooks ?? {});
+    const config = {
+        baseUrl: clientParams.baseUrl,
+        disabledPredictedMode: clientParams.disabledPredictedMode ?? false,
+        informationHeaderKey: clientParams.informationHeaderKey ?? "information",
+        predictedHeaderKey: clientParams.predictedHeaderKey ?? "predicted",
+        cache: clientParams.cache,
+        credentials: clientParams.credentials,
+    };
+    const defaultHeaders = new Map();
+    const self = httpClientKind.setTo({
+        config,
+        hooks,
+        defaultHeaders,
+        addDefaultHeader(headerName, headerValue) {
+            defaultHeaders.set(headerName, typeof headerValue === "function"
+                ? headerValue
+                : () => headerValue);
+        },
+        addDefaultHeaders(headers) {
+            for (const [header, headerValue] of OO__namespace.entries(headers)) {
+                self.addDefaultHeader(header, headerValue);
+            }
+        },
+        addRequestHook(hook) {
+            hooks.request.push(hook);
+        },
+        addResponseHook(hook) {
+            hooks.response.push(hook);
+        },
+        addInformationHook(information, hook) {
+            hooks.information[information] ??= [];
+            hooks.information[information].push(hook);
+        },
+        addCodeHook(code, hook) {
+            hooks.code[code] ??= [];
+            hooks.code[code].push(hook);
+        },
+        addInformationalResponseTypeHook(hook) {
+            hooks.informationalResponseType.push(hook);
+        },
+        addSuccessfulResponseTypeHook(hook) {
+            hooks.successfulResponseType.push(hook);
+        },
+        addRedirectionResponseTypeHook(hook) {
+            hooks.redirectionResponseType.push(hook);
+        },
+        addClientErrorResponseTypeHook(hook) {
+            hooks.clientErrorResponseType.push(hook);
+        },
+        addServerErrorResponseTypeHook(hook) {
+            hooks.serverErrorResponseType.push(hook);
+        },
+        addExpectedResponseHook(hook) {
+            hooks.expectedResponse.push(hook);
+        },
+        addNotPredictedResponseHook(hook) {
+            hooks.notPredictedResponse.push(hook);
+        },
+        addErrorHook(hook) {
+            hooks.error.push(hook);
+        },
+        request(params) {
+            const headers = GG__namespace.reduce(defaultHeaders.entries(), GG__namespace.reduceFrom({}), ({ element, lastValue, next }) => {
+                lastValue[element[0]] = `${element[1]()}`;
+                return next(lastValue);
+            });
+            return new promiseRequest.PromiseRequest({
+                hooks,
+                baseUrl: config.baseUrl,
+                ...params,
+                headers: {
+                    ...params.headers,
+                    ...headers,
+                },
+                initParams: {
+                    ...params.initParams,
+                    credentials: params.initParams?.credentials ?? clientParams.credentials,
+                    cache: params.initParams?.cache ?? clientParams.cache,
+                },
+                predictedHeaderKey: config.predictedHeaderKey,
+                informationHeaderKey: config.informationHeaderKey,
+                disabledPredicateMode: config.disabledPredictedMode,
+            });
+        },
+        get: ((path, params) => self.request({
+            method: "GET",
+            path,
+            ...params,
+        })),
+        post: ((path, params) => self.request({
+            method: "POST",
+            path,
+            ...params,
+        })),
+        put: ((path, params) => self.request({
+            method: "PUT",
+            path,
+            ...params,
+        })),
+        delete: ((path, params) => self.request({
+            method: "DELETE",
+            path,
+            ...params,
+        })),
+    });
+    return self;
+}
+
+exports.createHttpClient = createHttpClient;
+exports.httpClientKind = httpClientKind;

package/dist/client/httpClient.d.ts

@@ -0,0 +1,60 @@
+import { type Kind, type MayBeGetter, type NeverCoalescing, type SimplifyTopLevel } from "@duplojs/utils";
+import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams } from "./types";
+import { PromiseRequest, type PromiseRequestParams } from "./promiseRequest";
+import { type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type ErrorHook, type NotPredictedResponseHook } from "./hooks";
+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> = <GenericClientRequestParams extends NeverCoalescing<ServerRouteToClientRequestParams<Extract<GenericServerRoute, {
+    method: GenericMethod;
+}>, GenericHookParams>, ClientRequestParams<GenericHookParams>>, GenericPath extends GenericClientRequestParams["path"], GenericClientRequestRest extends SimplifyTopLevel<Omit<NeverCoalescing<Extract<GenericClientRequestParams, {
+    path: GenericPath;
+}>, ClientRequestParams<GenericHookParams>>, "method" | "path">>>(path: GenericPath, ...args: MaybeRequestParams<GenericClientRequestRest>) => PromiseRequest<PromiseRequestParams<GenericHookParams>, ServerRouteToClientResponse<NeverCoalescing<Extract<GenericServerRoute, {
+    method: GenericMethod;
+    path: GenericPath;
+}>, ServerRoute>, GenericHookParams>>;
+export interface HttpClientConfig {
+    readonly baseUrl: string;
+    readonly informationHeaderKey: string;
+    readonly predictedHeaderKey: string;
+    readonly disabledPredictedMode: boolean;
+    readonly credentials?: ClientRequestInitParams["credentials"];
+    readonly cache?: ClientRequestInitParams["cache"];
+}
+export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof httpClientKind.definition> {
+    readonly config: HttpClientConfig;
+    readonly hooks: Hooks;
+    readonly defaultHeaders: Map<string, () => (string | undefined | null)>;
+    addDefaultHeader(headerName: string, headerValue: MayBeGetter<string | undefined | null>): void;
+    addDefaultHeaders(headers: Record<string, MayBeGetter<string | undefined | null>>): void;
+    addRequestHook(hook: RequestHook<PromiseRequestParams<GenericHookParams>>): void;
+    addResponseHook(hook: ResponseHook<PromiseRequestParams<GenericHookParams>>): void;
+    addInformationHook(information: string, hook: InformationHook<PromiseRequestParams<GenericHookParams>>): void;
+    addCodeHook(code: string, hook: CodeHook<PromiseRequestParams<GenericHookParams>>): void;
+    addInformationalResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
+    addSuccessfulResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
+    addRedirectionResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
+    addClientErrorResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
+    addServerErrorResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
+    addExpectedResponseHook(hook: ExpectedResponseHook<PromiseRequestParams<GenericHookParams>>): void;
+    addNotPredictedResponseHook(hook: NotPredictedResponseHook<PromiseRequestParams<GenericHookParams>>): void;
+    addErrorHook(hook: ErrorHook<PromiseRequestParams<GenericHookParams>>): void;
+    request<GenericClientRequestParams extends ServerRouteToClientRequestParams<GenericServerRoute, GenericHookParams>>(params: GenericClientRequestParams): PromiseRequest<PromiseRequestParams<GenericHookParams>, ServerRouteToClientResponse<Extract<GenericServerRoute, {
+        method: GenericClientRequestParams["method"];
+        path: GenericClientRequestParams["path"];
+    }>, GenericHookParams>>;
+    get: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "GET">;
+    post: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "POST">;
+    put: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PUT">;
+    delete: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "DELETE">;
+}
+export interface CreateHttpClientParams {
+    readonly baseUrl: string;
+    readonly hooks?: Partial<Hooks>;
+    readonly credentials?: ClientRequestInitParams["credentials"];
+    readonly cache?: ClientRequestInitParams["cache"];
+    readonly informationHeaderKey?: string;
+    readonly predictedHeaderKey?: string;
+    readonly disabledPredictedMode?: boolean;
+}
+export declare function createHttpClient<GenericServerRoute extends ServerRoute = never, GenericHookParams extends Record<string, unknown> = Record<string, unknown>>(clientParams: CreateHttpClientParams): HttpClient<NeverCoalescing<GenericServerRoute, ServerRoute>, GenericHookParams>;
+export {};

package/dist/client/httpClient.mjs

@@ -0,0 +1,130 @@
+import * as OO from '@duplojs/utils/object';
+import * as GG from '@duplojs/utils/generator';
+import { createClientKind } from './kind.mjs';
+import { PromiseRequest } from './promiseRequest.mjs';
+
+const httpClientKind = createClientKind("http-client");
+function createHttpClient(clientParams) {
+    const hooks = OO.override({
+        request: [],
+        response: [],
+        information: {},
+        code: {},
+        informationalResponseType: [],
+        successfulResponseType: [],
+        redirectionResponseType: [],
+        clientErrorResponseType: [],
+        serverErrorResponseType: [],
+        expectedResponse: [],
+        error: [],
+        notPredictedResponse: [],
+    }, clientParams.hooks ?? {});
+    const config = {
+        baseUrl: clientParams.baseUrl,
+        disabledPredictedMode: clientParams.disabledPredictedMode ?? false,
+        informationHeaderKey: clientParams.informationHeaderKey ?? "information",
+        predictedHeaderKey: clientParams.predictedHeaderKey ?? "predicted",
+        cache: clientParams.cache,
+        credentials: clientParams.credentials,
+    };
+    const defaultHeaders = new Map();
+    const self = httpClientKind.setTo({
+        config,
+        hooks,
+        defaultHeaders,
+        addDefaultHeader(headerName, headerValue) {
+            defaultHeaders.set(headerName, typeof headerValue === "function"
+                ? headerValue
+                : () => headerValue);
+        },
+        addDefaultHeaders(headers) {
+            for (const [header, headerValue] of OO.entries(headers)) {
+                self.addDefaultHeader(header, headerValue);
+            }
+        },
+        addRequestHook(hook) {
+            hooks.request.push(hook);
+        },
+        addResponseHook(hook) {
+            hooks.response.push(hook);
+        },
+        addInformationHook(information, hook) {
+            hooks.information[information] ??= [];
+            hooks.information[information].push(hook);
+        },
+        addCodeHook(code, hook) {
+            hooks.code[code] ??= [];
+            hooks.code[code].push(hook);
+        },
+        addInformationalResponseTypeHook(hook) {
+            hooks.informationalResponseType.push(hook);
+        },
+        addSuccessfulResponseTypeHook(hook) {
+            hooks.successfulResponseType.push(hook);
+        },
+        addRedirectionResponseTypeHook(hook) {
+            hooks.redirectionResponseType.push(hook);
+        },
+        addClientErrorResponseTypeHook(hook) {
+            hooks.clientErrorResponseType.push(hook);
+        },
+        addServerErrorResponseTypeHook(hook) {
+            hooks.serverErrorResponseType.push(hook);
+        },
+        addExpectedResponseHook(hook) {
+            hooks.expectedResponse.push(hook);
+        },
+        addNotPredictedResponseHook(hook) {
+            hooks.notPredictedResponse.push(hook);
+        },
+        addErrorHook(hook) {
+            hooks.error.push(hook);
+        },
+        request(params) {
+            const headers = GG.reduce(defaultHeaders.entries(), GG.reduceFrom({}), ({ element, lastValue, next }) => {
+                lastValue[element[0]] = `${element[1]()}`;
+                return next(lastValue);
+            });
+            return new PromiseRequest({
+                hooks,
+                baseUrl: config.baseUrl,
+                ...params,
+                headers: {
+                    ...params.headers,
+                    ...headers,
+                },
+                initParams: {
+                    ...params.initParams,
+                    credentials: params.initParams?.credentials ?? clientParams.credentials,
+                    cache: params.initParams?.cache ?? clientParams.cache,
+                },
+                predictedHeaderKey: config.predictedHeaderKey,
+                informationHeaderKey: config.informationHeaderKey,
+                disabledPredicateMode: config.disabledPredictedMode,
+            });
+        },
+        get: ((path, params) => self.request({
+            method: "GET",
+            path,
+            ...params,
+        })),
+        post: ((path, params) => self.request({
+            method: "POST",
+            path,
+            ...params,
+        })),
+        put: ((path, params) => self.request({
+            method: "PUT",
+            path,
+            ...params,
+        })),
+        delete: ((path, params) => self.request({
+            method: "DELETE",
+            path,
+            ...params,
+        })),
+    });
+    return self;
+}
+
+export { createHttpClient, httpClientKind };

package/dist/client/index.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+require('./types/index.cjs');
+var kind = require('./kind.cjs');
+var httpClient = require('./httpClient.cjs');
+var hooks = require('./hooks.cjs');
+var getBody = require('./getBody.cjs');
+var insertParamsInPath = require('./insertParamsInPath.cjs');
+var queryToString = require('./queryToString.cjs');
+var promiseRequest = require('./promiseRequest.cjs');
+var unexpectedResponseError = require('./unexpectedResponseError.cjs');
+
+
+
+exports.createClientKind = kind.createClientKind;
+exports.createHttpClient = httpClient.createHttpClient;
+exports.httpClientKind = httpClient.httpClientKind;
+exports.launchCodeHook = hooks.launchCodeHook;
+exports.launchErrorHook = hooks.launchErrorHook;
+exports.launchExpectedResponseHook = hooks.launchExpectedResponseHook;
+exports.launchInformationHook = hooks.launchInformationHook;
+exports.launchNotPredictedHook = hooks.launchNotPredictedHook;
+exports.launchRequestHook = hooks.launchRequestHook;
+exports.launchResponseHook = hooks.launchResponseHook;
+exports.launchResponseTypeHook = hooks.launchResponseTypeHook;
+exports.getBody = getBody.getBody;
+exports.insertParamsInPath = insertParamsInPath.insertParamsInPath;
+exports.queryToString = queryToString.queryToString;
+exports.PromiseRequest = promiseRequest.PromiseRequest;
+exports.UnexpectedCodeResponseError = unexpectedResponseError.UnexpectedCodeResponseError;
+exports.UnexpectedInformationResponseError = unexpectedResponseError.UnexpectedInformationResponseError;
+exports.UnexpectedResponseError = unexpectedResponseError.UnexpectedResponseError;
+exports.UnexpectedResponseTypeError = unexpectedResponseError.UnexpectedResponseTypeError;

package/dist/client/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types";
+export * from "./kind";
+export * from "./httpClient";
+export * from "./hooks";
+export * from "./getBody";
+export * from "./insertParamsInPath";
+export * from "./queryToString";
+export * from "./promiseRequest";
+export * from "./unexpectedResponseError";

package/dist/client/index.mjs

@@ -0,0 +1,9 @@
+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 { 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';

package/dist/client/insertParamsInPath.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function insertParamsInPath(path, params) {
+    if (!params) {
+        return path;
+    }
+    return Object.entries(params).reduce((pv, [key, value]) => value
+        ? pv.replace(`{${key}}`, value.toString())
+        : pv, path);
+}
+
+exports.insertParamsInPath = insertParamsInPath;

package/dist/client/insertParamsInPath.d.ts

@@ -0,0 +1,2 @@
+import { type ClientRequestParams } from "./types";
+export declare function insertParamsInPath(path: string, params: ClientRequestParams["params"]): string;

package/dist/client/insertParamsInPath.mjs

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