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

package/dist/cjs/asserts/assertValidFetchAdapterOptions.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var isRecord = require('./isRecord.cjs');
+
+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.RequestBuilderError(message, requestBuilderErrorCodes.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.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');
+    }
+}
+
+exports.assertValidFetchAdapterOptions = assertValidFetchAdapterOptions;

package/dist/cjs/asserts/assertValidHeader.cjs

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

package/dist/cjs/asserts/assertValidHeaders.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var assertValidHeader = require('./assertValidHeader.cjs');
+var isRecord = require('./isRecord.cjs');
+
+function assertValidHeaders(headers) {
+    if (!isRecord.isRecord(headers)) {
+        throw new RequestBuilderError.RequestBuilderError('Headers must be an object', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_HEADERS);
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        assertValidHeader.assertValidHeader(key, value);
+    }
+}
+
+exports.assertValidHeaders = assertValidHeaders;

package/dist/cjs/asserts/assertValidHttpClientOptions.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var assertValidAdapter = require('./assertValidAdapter.cjs');
+var assertValidBaseUrl = require('./assertValidBaseUrl.cjs');
+var assertValidHeaders = require('./assertValidHeaders.cjs');
+var assertValidParams = require('./assertValidParams.cjs');
+var assertValidTimeout = require('./assertValidTimeout.cjs');
+var assertValidWithCredentials = require('./assertValidWithCredentials.cjs');
+var assertValidValidateStatus = require('./assertValidValidateStatus.cjs');
+var isRecord = require('./isRecord.cjs');
+
+function assertValidHook(hook, name) {
+    if (typeof hook !== 'function') {
+        throw new RequestBuilderError.RequestBuilderError(`${name} must be a function`, requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_HOOK);
+    }
+}
+/** Validates options passed to the HTTP client constructor. */
+function assertValidHttpClientOptions(options) {
+    if (!isRecord.isRecord(options)) {
+        throw new RequestBuilderError.RequestBuilderError('Client options must be an object', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_CONFIG);
+    }
+    const { adapter, baseUrl, headers, params, timeout, validateStatus, withCredentials, onRequest, onRequestError, onResponse, onResponseError } = options;
+    if (adapter !== undefined) {
+        assertValidAdapter.assertValidAdapter(adapter);
+    }
+    if (baseUrl !== undefined) {
+        assertValidBaseUrl.assertValidBaseUrl(baseUrl);
+    }
+    if (headers !== undefined) {
+        assertValidHeaders.assertValidHeaders(headers);
+    }
+    if (params !== undefined) {
+        assertValidParams.assertValidParams(params);
+    }
+    if (timeout !== undefined) {
+        assertValidTimeout.assertValidTimeout(timeout);
+    }
+    if (validateStatus !== undefined) {
+        assertValidValidateStatus.assertValidValidateStatus(validateStatus);
+    }
+    if (withCredentials !== undefined) {
+        assertValidWithCredentials.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');
+    }
+}
+
+exports.assertValidHttpClientOptions = assertValidHttpClientOptions;

package/dist/cjs/asserts/assertValidMethod.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var httpMethods = require('../constants/httpMethods.cjs');
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+
+function assertValidMethod(method) {
+    if (!Object.values(httpMethods.HTTP_METHODS).includes(method)) {
+        throw new RequestBuilderError.RequestBuilderError('Method must be a valid HTTP method', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_METHOD);
+    }
+}
+
+exports.assertValidMethod = assertValidMethod;

package/dist/cjs/asserts/assertValidParam.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var assertNonBlankString = require('./assertNonBlankString.cjs');
+
+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.assertNonBlankString(key, 'Param key must be a non-empty string', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_PARAM);
+    if (!isValidParamValue(value)) {
+        throw new RequestBuilderError.RequestBuilderError('Param value must be a string, finite number, boolean, null, undefined, or an array of these values', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_PARAM);
+    }
+}
+
+exports.assertValidParam = assertValidParam;

package/dist/cjs/asserts/assertValidParams.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var assertValidParam = require('./assertValidParam.cjs');
+var isRecord = require('./isRecord.cjs');
+
+function assertValidParams(params) {
+    if (!isRecord.isRecord(params)) {
+        throw new RequestBuilderError.RequestBuilderError('Params must be an object', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_PARAMS);
+    }
+    for (const [key, value] of Object.entries(params)) {
+        assertValidParam.assertValidParam(key, value);
+    }
+}
+
+exports.assertValidParams = assertValidParams;

package/dist/cjs/asserts/assertValidRequestConfig.cjs

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

package/dist/cjs/asserts/assertValidResponseType.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var httpResponseTypes = require('../constants/httpResponseTypes.cjs');
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+
+function assertValidResponseType(responseType) {
+    if (!Object.values(httpResponseTypes.HTTP_RESPONSE_TYPES).includes(responseType)) {
+        throw new RequestBuilderError.RequestBuilderError('Response type must be a valid HTTP response type', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_RESPONSE_TYPE);
+    }
+}
+
+exports.assertValidResponseType = assertValidResponseType;

package/dist/cjs/asserts/assertValidSignal.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+
+function assertValidSignal(signal) {
+    if (signal === null ||
+        typeof signal !== 'object' ||
+        typeof signal.aborted !== 'boolean' ||
+        typeof signal.addEventListener !== 'function' ||
+        typeof signal.removeEventListener !== 'function') {
+        throw new RequestBuilderError.RequestBuilderError('Signal must be an AbortSignal', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_SIGNAL);
+    }
+}
+
+exports.assertValidSignal = assertValidSignal;

package/dist/cjs/asserts/assertValidTimeout.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+
+function assertValidTimeout(timeout) {
+    if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout < 0) {
+        throw new RequestBuilderError.RequestBuilderError('Timeout must be a finite non-negative number', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_TIMEOUT);
+    }
+}
+
+exports.assertValidTimeout = assertValidTimeout;

package/dist/cjs/asserts/assertValidUrl.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var assertNonBlankString = require('./assertNonBlankString.cjs');
+
+function assertValidUrl(url) {
+    assertNonBlankString.assertNonBlankString(url, 'URL must be a non-empty string', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_URL);
+}
+
+exports.assertValidUrl = assertValidUrl;

package/dist/cjs/asserts/assertValidValidateStatus.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+
+/** Validates a custom HTTP response status predicate. */
+function assertValidValidateStatus(value) {
+    if (typeof value !== 'function') {
+        throw new RequestBuilderError.RequestBuilderError('validateStatus must be a function', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_VALIDATE_STATUS);
+    }
+}
+
+exports.assertValidValidateStatus = assertValidValidateStatus;

package/dist/cjs/asserts/assertValidWithCredentials.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+
+function assertValidWithCredentials(withCredentials) {
+    if (typeof withCredentials !== 'boolean') {
+        throw new RequestBuilderError.RequestBuilderError('withCredentials must be a boolean', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_WITH_CREDENTIALS);
+    }
+}
+
+exports.assertValidWithCredentials = assertValidWithCredentials;

package/dist/cjs/asserts/assertValidXhrAdapterOptions.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var assertValidResponseType = require('./assertValidResponseType.cjs');
+var assertValidTimeout = require('./assertValidTimeout.cjs');
+var assertValidWithCredentials = require('./assertValidWithCredentials.cjs');
+var isRecord = require('./isRecord.cjs');
+
+function throwInvalidOptions(message) {
+    throw new RequestBuilderError.RequestBuilderError(message, requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_XHR_ADAPTER_OPTIONS);
+}
+/** Validates options passed to the XMLHttpRequest adapter constructor. */
+function assertValidXhrAdapterOptions(options) {
+    if (!isRecord.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.assertValidResponseType(responseType);
+    }
+    if (timeout !== undefined) {
+        assertValidTimeout.assertValidTimeout(timeout);
+    }
+    if (withCredentials !== undefined) {
+        assertValidWithCredentials.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');
+    }
+}
+
+exports.assertValidXhrAdapterOptions = assertValidXhrAdapterOptions;

package/dist/cjs/asserts/headerValueLineBreakPattern.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const HEADER_VALUE_LINE_BREAK_PATTERN = /[\r\n]/;
+
+exports.HEADER_VALUE_LINE_BREAK_PATTERN = HEADER_VALUE_LINE_BREAK_PATTERN;

package/dist/cjs/asserts/isRecord.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+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;
+}
+
+exports.isRecord = isRecord;

package/dist/cjs/constants/httpMethods.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const HTTP_METHODS = {
+    GET: 'GET',
+    HEAD: 'HEAD',
+    POST: 'POST',
+    PUT: 'PUT',
+    DELETE: 'DELETE',
+    OPTIONS: 'OPTIONS',
+    PATCH: 'PATCH'
+};
+
+exports.HTTP_METHODS = HTTP_METHODS;

package/dist/cjs/constants/httpResponseTypes.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const HTTP_RESPONSE_TYPES = {
+    ARRAY_BUFFER: 'arrayBuffer',
+    BLOB: 'blob',
+    JSON: 'json',
+    STREAM: 'stream',
+    TEXT: 'text'
+};
+
+exports.HTTP_RESPONSE_TYPES = HTTP_RESPONSE_TYPES;

package/dist/cjs/constants/httpStatusCodes.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+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
+};
+
+exports.HTTP_STATUS_CODES = HTTP_STATUS_CODES;

package/dist/cjs/constants/requestBuilderErrorCodes.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+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'
+};
+
+exports.REQUEST_BUILDER_ERROR_CODES = REQUEST_BUILDER_ERROR_CODES;