@byndyusoft-ui/http-client 0.1.0-alpha.0

package/dist/esm/asserts/assertValidFetchAdapterOptions.js

@@ -0,0 +1,68 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { isRecord } from './isRecord.js';
+
+const FETCH_CACHE_VALUES = ['default', 'no-store', 'reload', 'no-cache', 'force-cache', 'only-if-cached'];
+const FETCH_CREDENTIALS_VALUES = ['omit', 'same-origin', 'include'];
+const FETCH_MODE_VALUES = ['cors', 'no-cors', 'same-origin'];
+const FETCH_REDIRECT_VALUES = ['error', 'follow', 'manual'];
+const FETCH_REFERRER_POLICY_VALUES = [
+    '',
+    'no-referrer',
+    'no-referrer-when-downgrade',
+    'origin',
+    'origin-when-cross-origin',
+    'same-origin',
+    'strict-origin',
+    'strict-origin-when-cross-origin',
+    'unsafe-url'
+];
+function throwInvalidOptions(message) {
+    throw new RequestBuilderError(message, REQUEST_BUILDER_ERROR_CODES.INVALID_FETCH_ADAPTER_OPTIONS);
+}
+function assertValidEnum(value, values, name) {
+    if (typeof value !== 'string' || !values.includes(value)) {
+        throwInvalidOptions(`${name} must be a valid Fetch option`);
+    }
+}
+function assertValidString(value, name) {
+    if (typeof value !== 'string') {
+        throwInvalidOptions(`${name} must be a string`);
+    }
+}
+/** Validates options passed to the Fetch adapter constructor. */
+function assertValidFetchAdapterOptions(options) {
+    if (!isRecord(options)) {
+        throwInvalidOptions('Fetch adapter options must be an object');
+    }
+    const { cache, credentials, integrity, keepalive, mode, redirect, referrer, referrerPolicy } = options;
+    if (cache !== undefined) {
+        assertValidEnum(cache, FETCH_CACHE_VALUES, 'cache');
+    }
+    if (credentials !== undefined) {
+        assertValidEnum(credentials, FETCH_CREDENTIALS_VALUES, 'credentials');
+    }
+    if (integrity !== undefined) {
+        assertValidString(integrity, 'integrity');
+    }
+    if (keepalive !== undefined && typeof keepalive !== 'boolean') {
+        throwInvalidOptions('keepalive must be a boolean');
+    }
+    if (mode !== undefined) {
+        assertValidEnum(mode, FETCH_MODE_VALUES, 'mode');
+    }
+    if (cache === 'only-if-cached' && mode !== 'same-origin') {
+        throwInvalidOptions('cache "only-if-cached" requires mode "same-origin"');
+    }
+    if (redirect !== undefined) {
+        assertValidEnum(redirect, FETCH_REDIRECT_VALUES, 'redirect');
+    }
+    if (referrer !== undefined) {
+        assertValidString(referrer, 'referrer');
+    }
+    if (referrerPolicy !== undefined) {
+        assertValidEnum(referrerPolicy, FETCH_REFERRER_POLICY_VALUES, 'referrerPolicy');
+    }
+}
+
+export { assertValidFetchAdapterOptions };

package/dist/esm/asserts/assertValidHeader.js

@@ -0,0 +1,16 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertNonBlankString } from './assertNonBlankString.js';
+import { HEADER_VALUE_LINE_BREAK_PATTERN } from './headerValueLineBreakPattern.js';
+
+function assertValidHeader(key, value) {
+    assertNonBlankString(key, 'Header key must be a non-empty string', REQUEST_BUILDER_ERROR_CODES.INVALID_HEADER);
+    if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(key)) {
+        throw new RequestBuilderError('Header key contains invalid characters', REQUEST_BUILDER_ERROR_CODES.INVALID_HEADER);
+    }
+    if (typeof value !== 'string' || HEADER_VALUE_LINE_BREAK_PATTERN.test(value)) {
+        throw new RequestBuilderError('Header value must be a string without line breaks', REQUEST_BUILDER_ERROR_CODES.INVALID_HEADER);
+    }
+}
+
+export { assertValidHeader };

package/dist/esm/asserts/assertValidHeaders.js

@@ -0,0 +1,15 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertValidHeader } from './assertValidHeader.js';
+import { isRecord } from './isRecord.js';
+
+function assertValidHeaders(headers) {
+    if (!isRecord(headers)) {
+        throw new RequestBuilderError('Headers must be an object', REQUEST_BUILDER_ERROR_CODES.INVALID_HEADERS);
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        assertValidHeader(key, value);
+    }
+}
+
+export { assertValidHeaders };

package/dist/esm/asserts/assertValidHttpClientOptions.js

@@ -0,0 +1,58 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertValidAdapter } from './assertValidAdapter.js';
+import { assertValidBaseUrl } from './assertValidBaseUrl.js';
+import { assertValidHeaders } from './assertValidHeaders.js';
+import { assertValidParams } from './assertValidParams.js';
+import { assertValidTimeout } from './assertValidTimeout.js';
+import { assertValidWithCredentials } from './assertValidWithCredentials.js';
+import { assertValidValidateStatus } from './assertValidValidateStatus.js';
+import { isRecord } from './isRecord.js';
+
+function assertValidHook(hook, name) {
+    if (typeof hook !== 'function') {
+        throw new RequestBuilderError(`${name} must be a function`, REQUEST_BUILDER_ERROR_CODES.INVALID_HOOK);
+    }
+}
+/** Validates options passed to the HTTP client constructor. */
+function assertValidHttpClientOptions(options) {
+    if (!isRecord(options)) {
+        throw new RequestBuilderError('Client options must be an object', REQUEST_BUILDER_ERROR_CODES.INVALID_CONFIG);
+    }
+    const { adapter, baseUrl, headers, params, timeout, validateStatus, withCredentials, onRequest, onRequestError, onResponse, onResponseError } = options;
+    if (adapter !== undefined) {
+        assertValidAdapter(adapter);
+    }
+    if (baseUrl !== undefined) {
+        assertValidBaseUrl(baseUrl);
+    }
+    if (headers !== undefined) {
+        assertValidHeaders(headers);
+    }
+    if (params !== undefined) {
+        assertValidParams(params);
+    }
+    if (timeout !== undefined) {
+        assertValidTimeout(timeout);
+    }
+    if (validateStatus !== undefined) {
+        assertValidValidateStatus(validateStatus);
+    }
+    if (withCredentials !== undefined) {
+        assertValidWithCredentials(withCredentials);
+    }
+    if (onRequest !== undefined) {
+        assertValidHook(onRequest, 'onRequest');
+    }
+    if (onRequestError !== undefined) {
+        assertValidHook(onRequestError, 'onRequestError');
+    }
+    if (onResponse !== undefined) {
+        assertValidHook(onResponse, 'onResponse');
+    }
+    if (onResponseError !== undefined) {
+        assertValidHook(onResponseError, 'onResponseError');
+    }
+}
+
+export { assertValidHttpClientOptions };

package/dist/esm/asserts/assertValidMethod.js

@@ -0,0 +1,11 @@
+import { HTTP_METHODS } from '../constants/httpMethods.js';
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+
+function assertValidMethod(method) {
+    if (!Object.values(HTTP_METHODS).includes(method)) {
+        throw new RequestBuilderError('Method must be a valid HTTP method', REQUEST_BUILDER_ERROR_CODES.INVALID_METHOD);
+    }
+}
+
+export { assertValidMethod };

package/dist/esm/asserts/assertValidParam.js

@@ -0,0 +1,21 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertNonBlankString } from './assertNonBlankString.js';
+
+function isValidParamPrimitive(value) {
+    return (typeof value === 'string' || typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value)));
+}
+function isValidParamValue(value) {
+    if (value === null || value === undefined || isValidParamPrimitive(value)) {
+        return true;
+    }
+    return (Array.isArray(value) && value.every(item => item === null || item === undefined || isValidParamPrimitive(item)));
+}
+function assertValidParam(key, value) {
+    assertNonBlankString(key, 'Param key must be a non-empty string', REQUEST_BUILDER_ERROR_CODES.INVALID_PARAM);
+    if (!isValidParamValue(value)) {
+        throw new RequestBuilderError('Param value must be a string, finite number, boolean, null, undefined, or an array of these values', REQUEST_BUILDER_ERROR_CODES.INVALID_PARAM);
+    }
+}
+
+export { assertValidParam };

package/dist/esm/asserts/assertValidParams.js

@@ -0,0 +1,15 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertValidParam } from './assertValidParam.js';
+import { isRecord } from './isRecord.js';
+
+function assertValidParams(params) {
+    if (!isRecord(params)) {
+        throw new RequestBuilderError('Params must be an object', REQUEST_BUILDER_ERROR_CODES.INVALID_PARAMS);
+    }
+    for (const [key, value] of Object.entries(params)) {
+        assertValidParam(key, value);
+    }
+}
+
+export { assertValidParams };

package/dist/esm/asserts/assertValidRequestConfig.js

@@ -0,0 +1,53 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertValidBody } from './assertValidBody.js';
+import { assertValidBaseUrl } from './assertValidBaseUrl.js';
+import { assertValidHeaders } from './assertValidHeaders.js';
+import { assertValidMethod } from './assertValidMethod.js';
+import { assertValidParams } from './assertValidParams.js';
+import { assertValidResponseType } from './assertValidResponseType.js';
+import { assertValidSignal } from './assertValidSignal.js';
+import { assertValidTimeout } from './assertValidTimeout.js';
+import { assertValidUrl } from './assertValidUrl.js';
+import { assertValidWithCredentials } from './assertValidWithCredentials.js';
+import { assertValidValidateStatus } from './assertValidValidateStatus.js';
+import { isRecord } from './isRecord.js';
+
+/** Validates a complete request config, including values returned by request hooks. */
+function assertValidRequestConfig(config) {
+    if (!isRecord(config)) {
+        throw new RequestBuilderError('Request config must be an object', REQUEST_BUILDER_ERROR_CODES.INVALID_CONFIG);
+    }
+    const { method, url, baseUrl, headers, params, data, signal, timeout, validateStatus, withCredentials, responseType } = config;
+    assertValidMethod(method);
+    assertValidUrl(url);
+    if (baseUrl !== undefined) {
+        assertValidBaseUrl(baseUrl);
+    }
+    if (headers !== undefined) {
+        assertValidHeaders(headers);
+    }
+    if (params !== undefined) {
+        assertValidParams(params);
+    }
+    if (signal !== undefined) {
+        assertValidSignal(signal);
+    }
+    if (timeout !== undefined) {
+        assertValidTimeout(timeout);
+    }
+    if (validateStatus !== undefined) {
+        assertValidValidateStatus(validateStatus);
+    }
+    if (withCredentials !== undefined) {
+        assertValidWithCredentials(withCredentials);
+    }
+    if (responseType !== undefined) {
+        assertValidResponseType(responseType);
+    }
+    if (Object.prototype.hasOwnProperty.call(config, 'data')) {
+        assertValidBody(method, data);
+    }
+}
+
+export { assertValidRequestConfig };

package/dist/esm/asserts/assertValidResponseType.js

@@ -0,0 +1,11 @@
+import { HTTP_RESPONSE_TYPES } from '../constants/httpResponseTypes.js';
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+
+function assertValidResponseType(responseType) {
+    if (!Object.values(HTTP_RESPONSE_TYPES).includes(responseType)) {
+        throw new RequestBuilderError('Response type must be a valid HTTP response type', REQUEST_BUILDER_ERROR_CODES.INVALID_RESPONSE_TYPE);
+    }
+}
+
+export { assertValidResponseType };

package/dist/esm/asserts/assertValidSignal.js

@@ -0,0 +1,14 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+
+function assertValidSignal(signal) {
+    if (signal === null ||
+        typeof signal !== 'object' ||
+        typeof signal.aborted !== 'boolean' ||
+        typeof signal.addEventListener !== 'function' ||
+        typeof signal.removeEventListener !== 'function') {
+        throw new RequestBuilderError('Signal must be an AbortSignal', REQUEST_BUILDER_ERROR_CODES.INVALID_SIGNAL);
+    }
+}
+
+export { assertValidSignal };

package/dist/esm/asserts/assertValidTimeout.js

@@ -0,0 +1,10 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+
+function assertValidTimeout(timeout) {
+    if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout < 0) {
+        throw new RequestBuilderError('Timeout must be a finite non-negative number', REQUEST_BUILDER_ERROR_CODES.INVALID_TIMEOUT);
+    }
+}
+
+export { assertValidTimeout };

package/dist/esm/asserts/assertValidUrl.js

@@ -0,0 +1,8 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { assertNonBlankString } from './assertNonBlankString.js';
+
+function assertValidUrl(url) {
+    assertNonBlankString(url, 'URL must be a non-empty string', REQUEST_BUILDER_ERROR_CODES.INVALID_URL);
+}
+
+export { assertValidUrl };

package/dist/esm/asserts/assertValidValidateStatus.js

@@ -0,0 +1,11 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+
+/** Validates a custom HTTP response status predicate. */
+function assertValidValidateStatus(value) {
+    if (typeof value !== 'function') {
+        throw new RequestBuilderError('validateStatus must be a function', REQUEST_BUILDER_ERROR_CODES.INVALID_VALIDATE_STATUS);
+    }
+}
+
+export { assertValidValidateStatus };

package/dist/esm/asserts/assertValidWithCredentials.js

@@ -0,0 +1,10 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+
+function assertValidWithCredentials(withCredentials) {
+    if (typeof withCredentials !== 'boolean') {
+        throw new RequestBuilderError('withCredentials must be a boolean', REQUEST_BUILDER_ERROR_CODES.INVALID_WITH_CREDENTIALS);
+    }
+}
+
+export { assertValidWithCredentials };

package/dist/esm/asserts/assertValidXhrAdapterOptions.js

@@ -0,0 +1,37 @@
+import { REQUEST_BUILDER_ERROR_CODES } from '../constants/requestBuilderErrorCodes.js';
+import { RequestBuilderError } from '../errors/RequestBuilderError.js';
+import { assertValidResponseType } from './assertValidResponseType.js';
+import { assertValidTimeout } from './assertValidTimeout.js';
+import { assertValidWithCredentials } from './assertValidWithCredentials.js';
+import { isRecord } from './isRecord.js';
+
+function throwInvalidOptions(message) {
+    throw new RequestBuilderError(message, REQUEST_BUILDER_ERROR_CODES.INVALID_XHR_ADAPTER_OPTIONS);
+}
+/** Validates options passed to the XMLHttpRequest adapter constructor. */
+function assertValidXhrAdapterOptions(options) {
+    if (!isRecord(options)) {
+        throwInvalidOptions('XHR adapter options must be an object');
+    }
+    const { mimeType, responseType, timeout, withCredentials, onDownloadProgress, onUploadProgress } = options;
+    if (mimeType !== undefined && (typeof mimeType !== 'string' || mimeType.trim().length === 0)) {
+        throwInvalidOptions('mimeType must be a non-empty string');
+    }
+    if (responseType !== undefined) {
+        assertValidResponseType(responseType);
+    }
+    if (timeout !== undefined) {
+        assertValidTimeout(timeout);
+    }
+    if (withCredentials !== undefined) {
+        assertValidWithCredentials(withCredentials);
+    }
+    if (onDownloadProgress !== undefined && typeof onDownloadProgress !== 'function') {
+        throwInvalidOptions('onDownloadProgress must be a function');
+    }
+    if (onUploadProgress !== undefined && typeof onUploadProgress !== 'function') {
+        throwInvalidOptions('onUploadProgress must be a function');
+    }
+}
+
+export { assertValidXhrAdapterOptions };

package/dist/esm/asserts/headerValueLineBreakPattern.js

@@ -0,0 +1,3 @@
+const HEADER_VALUE_LINE_BREAK_PATTERN = /[\r\n]/;
+
+export { HEADER_VALUE_LINE_BREAK_PATTERN };

package/dist/esm/asserts/isRecord.js

@@ -0,0 +1,9 @@
+function isRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+
+export { isRecord };

package/dist/esm/constants/httpMethods.js

@@ -0,0 +1,11 @@
+const HTTP_METHODS = {
+    GET: 'GET',
+    HEAD: 'HEAD',
+    POST: 'POST',
+    PUT: 'PUT',
+    DELETE: 'DELETE',
+    OPTIONS: 'OPTIONS',
+    PATCH: 'PATCH'
+};
+
+export { HTTP_METHODS };

package/dist/esm/constants/httpResponseTypes.js

@@ -0,0 +1,9 @@
+const HTTP_RESPONSE_TYPES = {
+    ARRAY_BUFFER: 'arrayBuffer',
+    BLOB: 'blob',
+    JSON: 'json',
+    STREAM: 'stream',
+    TEXT: 'text'
+};
+
+export { HTTP_RESPONSE_TYPES };

package/dist/esm/constants/httpStatusCodes.js

@@ -0,0 +1,66 @@
+const HTTP_STATUS_CODES = {
+    CONTINUE: 100,
+    SWITCHING_PROTOCOLS: 101,
+    PROCESSING: 102,
+    EARLY_HINTS: 103,
+    OK: 200,
+    CREATED: 201,
+    ACCEPTED: 202,
+    NON_AUTHORITATIVE_INFORMATION: 203,
+    NO_CONTENT: 204,
+    RESET_CONTENT: 205,
+    PARTIAL_CONTENT: 206,
+    MULTI_STATUS: 207,
+    ALREADY_REPORTED: 208,
+    IM_USED: 226,
+    MULTIPLE_CHOICES: 300,
+    MOVED_PERMANENTLY: 301,
+    FOUND: 302,
+    SEE_OTHER: 303,
+    NOT_MODIFIED: 304,
+    USE_PROXY: 305,
+    TEMPORARY_REDIRECT: 307,
+    PERMANENT_REDIRECT: 308,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    PAYMENT_REQUIRED: 402,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    METHOD_NOT_ALLOWED: 405,
+    NOT_ACCEPTABLE: 406,
+    PROXY_AUTHENTICATION_REQUIRED: 407,
+    REQUEST_TIMEOUT: 408,
+    CONFLICT: 409,
+    GONE: 410,
+    LENGTH_REQUIRED: 411,
+    PRECONDITION_FAILED: 412,
+    PAYLOAD_TOO_LARGE: 413,
+    URI_TOO_LONG: 414,
+    UNSUPPORTED_MEDIA_TYPE: 415,
+    RANGE_NOT_SATISFIABLE: 416,
+    EXPECTATION_FAILED: 417,
+    IM_A_TEAPOT: 418,
+    MISDIRECTED_REQUEST: 421,
+    UNPROCESSABLE_ENTITY: 422,
+    LOCKED: 423,
+    FAILED_DEPENDENCY: 424,
+    TOO_EARLY: 425,
+    UPGRADE_REQUIRED: 426,
+    PRECONDITION_REQUIRED: 428,
+    TOO_MANY_REQUESTS: 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504,
+    HTTP_VERSION_NOT_SUPPORTED: 505,
+    VARIANT_ALSO_NEGOTIATES: 506,
+    INSUFFICIENT_STORAGE: 507,
+    LOOP_DETECTED: 508,
+    NOT_EXTENDED: 510,
+    NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+
+export { HTTP_STATUS_CODES };

package/dist/esm/constants/requestBuilderErrorCodes.js

@@ -0,0 +1,24 @@
+const REQUEST_BUILDER_ERROR_CODES = {
+    INVALID_BASE_URL: 'INVALID_BASE_URL',
+    INVALID_BEARER_TOKEN: 'INVALID_BEARER_TOKEN',
+    INVALID_ADAPTER: 'INVALID_ADAPTER',
+    INVALID_BODY: 'INVALID_BODY',
+    INVALID_CONFIG: 'INVALID_CONFIG',
+    INVALID_EXECUTOR: 'INVALID_EXECUTOR',
+    INVALID_FETCH_ADAPTER_OPTIONS: 'INVALID_FETCH_ADAPTER_OPTIONS',
+    INVALID_HEADER: 'INVALID_HEADER',
+    INVALID_HEADERS: 'INVALID_HEADERS',
+    INVALID_HOOK: 'INVALID_HOOK',
+    INVALID_METHOD: 'INVALID_METHOD',
+    INVALID_PARAM: 'INVALID_PARAM',
+    INVALID_PARAMS: 'INVALID_PARAMS',
+    INVALID_RESPONSE_TYPE: 'INVALID_RESPONSE_TYPE',
+    INVALID_SIGNAL: 'INVALID_SIGNAL',
+    INVALID_TIMEOUT: 'INVALID_TIMEOUT',
+    INVALID_URL: 'INVALID_URL',
+    INVALID_VALIDATE_STATUS: 'INVALID_VALIDATE_STATUS',
+    INVALID_WITH_CREDENTIALS: 'INVALID_WITH_CREDENTIALS',
+    INVALID_XHR_ADAPTER_OPTIONS: 'INVALID_XHR_ADAPTER_OPTIONS'
+};
+
+export { REQUEST_BUILDER_ERROR_CODES };

package/dist/esm/core/HttpClient.js

@@ -0,0 +1,139 @@
+import { HTTP_METHODS } from '../constants/httpMethods.js';
+import { assertValidAdapter } from '../asserts/assertValidAdapter.js';
+import { assertValidHttpClientOptions } from '../asserts/assertValidHttpClientOptions.js';
+import { assertValidRequestConfig } from '../asserts/assertValidRequestConfig.js';
+import { FetchAdapter } from '../adapters/FetchAdapter.js';
+import { mergeHeaders } from '../utilities/mergeHeaders.js';
+import { mergeParams } from '../utilities/mergeParams.js';
+import { HttpRequestBuilder } from './HttpRequestBuilder.js';
+
+class HttpClient {
+    adapter;
+    defaultConfig;
+    onRequestHook;
+    onRequestErrorHook;
+    onResponseHook;
+    onResponseErrorHook;
+    constructor(options) {
+        assertValidHttpClientOptions(options);
+        this.adapter = options.adapter ?? new FetchAdapter();
+        this.onRequestHook = options.onRequest;
+        this.onRequestErrorHook = options.onRequestError;
+        this.onResponseHook = options.onResponse;
+        this.onResponseErrorHook = options.onResponseError;
+        this.defaultConfig = {
+            baseUrl: options.baseUrl,
+            headers: mergeHeaders(options.headers),
+            params: mergeParams(options.params),
+            timeout: options.timeout,
+            validateStatus: options.validateStatus,
+            withCredentials: options.withCredentials
+        };
+    }
+    /** Creates an independent client with the current defaults and hooks, using the provided adapter. */
+    withAdapter(adapter) {
+        assertValidAdapter(adapter);
+        return new HttpClient({
+            ...this.defaultConfig,
+            adapter,
+            onRequest: this.onRequestHook,
+            onRequestError: this.onRequestErrorHook,
+            onResponse: this.onResponseHook,
+            onResponseError: this.onResponseErrorHook
+        });
+    }
+    /** Sets the onRequest hook, replacing the hook configured through constructor options. Returns this client for chaining. */
+    onRequest(hook) {
+        this.onRequestHook = hook;
+        return this;
+    }
+    /** Sets the onRequestError hook, replacing the hook configured through constructor options. Returns this client for chaining. */
+    onRequestError(hook) {
+        this.onRequestErrorHook = hook;
+        return this;
+    }
+    /** Sets the onResponse hook, replacing the hook configured through constructor options. Returns this client for chaining. */
+    onResponse(hook) {
+        this.onResponseHook = hook;
+        return this;
+    }
+    /** Sets the onResponseError hook, replacing the hook configured through constructor options. Returns this client for chaining. */
+    onResponseError(hook) {
+        this.onResponseErrorHook = hook;
+        return this;
+    }
+    request(method, url) {
+        const executor = (config) => this.executeRequest(config);
+        return new HttpRequestBuilder(executor, method, url);
+    }
+    get(url) {
+        return this.request(HTTP_METHODS.GET, url);
+    }
+    head(url) {
+        return this.request(HTTP_METHODS.HEAD, url);
+    }
+    post(url) {
+        return this.request(HTTP_METHODS.POST, url);
+    }
+    put(url) {
+        return this.request(HTTP_METHODS.PUT, url);
+    }
+    delete(url) {
+        return this.request(HTTP_METHODS.DELETE, url);
+    }
+    options(url) {
+        return this.request(HTTP_METHODS.OPTIONS, url);
+    }
+    patch(url) {
+        return this.request(HTTP_METHODS.PATCH, url);
+    }
+    async executeRequest(config) {
+        const { onRequestHook: onRequest, onRequestErrorHook: onRequestError, onResponseHook: onResponse, onResponseErrorHook: onResponseError } = this;
+        let mergedConfig = {
+            ...config,
+            baseUrl: config.baseUrl ?? this.defaultConfig.baseUrl,
+            timeout: config.timeout ?? this.defaultConfig.timeout,
+            validateStatus: config.validateStatus ?? this.defaultConfig.validateStatus,
+            withCredentials: config.withCredentials ?? this.defaultConfig.withCredentials,
+            headers: mergeHeaders(this.defaultConfig.headers, config.headers),
+            params: mergeParams(this.defaultConfig.params, config.params)
+        };
+        if (onRequest !== undefined) {
+            try {
+                const requestConfig = await onRequest(mergedConfig);
+                assertValidRequestConfig(requestConfig);
+                mergedConfig = requestConfig;
+            }
+            catch (error) {
+                if (onRequestError === undefined) {
+                    throw error;
+                }
+                const recoveredConfig = await onRequestError(error);
+                if (recoveredConfig === undefined) {
+                    throw error;
+                }
+                assertValidRequestConfig(recoveredConfig);
+                mergedConfig = recoveredConfig;
+            }
+        }
+        try {
+            let response = await this.adapter.request(mergedConfig);
+            if (onResponse !== undefined) {
+                response = await onResponse(response);
+            }
+            return response;
+        }
+        catch (error) {
+            if (onResponseError === undefined) {
+                throw error;
+            }
+            const recoveredResponse = await onResponseError(error);
+            if (recoveredResponse === undefined) {
+                throw error;
+            }
+            return recoveredResponse;
+        }
+    }
+}
+
+export { HttpClient };