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

package/dist/cjs/core/HttpClient.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+var httpMethods = require('../constants/httpMethods.cjs');
+var assertValidAdapter = require('../asserts/assertValidAdapter.cjs');
+var assertValidHttpClientOptions = require('../asserts/assertValidHttpClientOptions.cjs');
+var assertValidRequestConfig = require('../asserts/assertValidRequestConfig.cjs');
+var FetchAdapter = require('../adapters/FetchAdapter.cjs');
+var mergeHeaders = require('../utilities/mergeHeaders.cjs');
+var mergeParams = require('../utilities/mergeParams.cjs');
+var HttpRequestBuilder = require('./HttpRequestBuilder.cjs');
+
+class HttpClient {
+    adapter;
+    defaultConfig;
+    onRequestHook;
+    onRequestErrorHook;
+    onResponseHook;
+    onResponseErrorHook;
+    constructor(options) {
+        assertValidHttpClientOptions.assertValidHttpClientOptions(options);
+        this.adapter = options.adapter ?? new FetchAdapter.FetchAdapter();
+        this.onRequestHook = options.onRequest;
+        this.onRequestErrorHook = options.onRequestError;
+        this.onResponseHook = options.onResponse;
+        this.onResponseErrorHook = options.onResponseError;
+        this.defaultConfig = {
+            baseUrl: options.baseUrl,
+            headers: mergeHeaders.mergeHeaders(options.headers),
+            params: mergeParams.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.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.HttpRequestBuilder(executor, method, url);
+    }
+    get(url) {
+        return this.request(httpMethods.HTTP_METHODS.GET, url);
+    }
+    head(url) {
+        return this.request(httpMethods.HTTP_METHODS.HEAD, url);
+    }
+    post(url) {
+        return this.request(httpMethods.HTTP_METHODS.POST, url);
+    }
+    put(url) {
+        return this.request(httpMethods.HTTP_METHODS.PUT, url);
+    }
+    delete(url) {
+        return this.request(httpMethods.HTTP_METHODS.DELETE, url);
+    }
+    options(url) {
+        return this.request(httpMethods.HTTP_METHODS.OPTIONS, url);
+    }
+    patch(url) {
+        return this.request(httpMethods.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.mergeHeaders(this.defaultConfig.headers, config.headers),
+            params: mergeParams.mergeParams(this.defaultConfig.params, config.params)
+        };
+        if (onRequest !== undefined) {
+            try {
+                const requestConfig = await onRequest(mergedConfig);
+                assertValidRequestConfig.assertValidRequestConfig(requestConfig);
+                mergedConfig = requestConfig;
+            }
+            catch (error) {
+                if (onRequestError === undefined) {
+                    throw error;
+                }
+                const recoveredConfig = await onRequestError(error);
+                if (recoveredConfig === undefined) {
+                    throw error;
+                }
+                assertValidRequestConfig.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;
+        }
+    }
+}
+
+exports.HttpClient = HttpClient;

package/dist/cjs/core/HttpRequestBuilder.cjs

@@ -0,0 +1,129 @@
+'use strict';
+
+var httpResponseTypes = require('../constants/httpResponseTypes.cjs');
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var RequestBuilderError = require('../errors/RequestBuilderError.cjs');
+var assertValidBody = require('../asserts/assertValidBody.cjs');
+var assertNonBlankString = require('../asserts/assertNonBlankString.cjs');
+var assertValidBaseUrl = require('../asserts/assertValidBaseUrl.cjs');
+var assertValidHeader = require('../asserts/assertValidHeader.cjs');
+var assertValidHeaders = require('../asserts/assertValidHeaders.cjs');
+var assertValidParams = require('../asserts/assertValidParams.cjs');
+var assertValidTimeout = require('../asserts/assertValidTimeout.cjs');
+var assertValidWithCredentials = require('../asserts/assertValidWithCredentials.cjs');
+var assertValidValidateStatus = require('../asserts/assertValidValidateStatus.cjs');
+var assertValidMethod = require('../asserts/assertValidMethod.cjs');
+var assertValidParam = require('../asserts/assertValidParam.cjs');
+var assertValidRequestConfig = require('../asserts/assertValidRequestConfig.cjs');
+var assertValidSignal = require('../asserts/assertValidSignal.cjs');
+var assertValidUrl = require('../asserts/assertValidUrl.cjs');
+var headerValueLineBreakPattern = require('../asserts/headerValueLineBreakPattern.cjs');
+var mergeHeaders = require('../utilities/mergeHeaders.cjs');
+var mergeParams = require('../utilities/mergeParams.cjs');
+
+function cloneConfig(config) {
+    return {
+        ...config,
+        ...(config.headers === undefined ? {} : { headers: { ...config.headers } }),
+        ...(config.params === undefined ? {} : { params: mergeParams.mergeParams(config.params) })
+    };
+}
+/**
+ * Builds request configs immutably. Every configuration method returns a new builder instance.
+ */
+class HttpRequestBuilder {
+    executor;
+    config;
+    constructor(executor, method, url) {
+        if (typeof executor !== 'function') {
+            throw new RequestBuilderError.RequestBuilderError('Executor must be a function', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_EXECUTOR);
+        }
+        assertValidMethod.assertValidMethod(method);
+        assertValidUrl.assertValidUrl(url);
+        this.executor = executor;
+        this.config = { method, url };
+    }
+    withConfig(partial) {
+        const builder = new HttpRequestBuilder(this.executor, this.config.method, this.config.url);
+        builder.config = cloneConfig({ ...this.config, ...partial });
+        return builder;
+    }
+    build() {
+        assertValidRequestConfig.assertValidRequestConfig(this.config);
+        return cloneConfig(this.config);
+    }
+    baseUrl(value) {
+        assertValidBaseUrl.assertValidBaseUrl(value);
+        return this.withConfig({ baseUrl: value });
+    }
+    header(key, value) {
+        assertValidHeader.assertValidHeader(key, value);
+        return this.withConfig({ headers: mergeHeaders.mergeHeaders(this.config.headers, { [key]: value }) });
+    }
+    headers(headers) {
+        assertValidHeaders.assertValidHeaders(headers);
+        return this.withConfig({ headers: mergeHeaders.mergeHeaders(this.config.headers, headers) });
+    }
+    param(key, value) {
+        assertValidParam.assertValidParam(key, value);
+        return this.withConfig({
+            params: mergeParams.mergeParams(this.config.params, { [key]: value })
+        });
+    }
+    params(params) {
+        assertValidParams.assertValidParams(params);
+        return this.withConfig({
+            params: mergeParams.mergeParams(this.config.params, params)
+        });
+    }
+    body(data) {
+        assertValidBody.assertValidBody(this.config.method, data);
+        return this.withConfig({ data });
+    }
+    signal(signal) {
+        assertValidSignal.assertValidSignal(signal);
+        return this.withConfig({ signal });
+    }
+    /** A zero timeout disables the request timeout, including a timeout inherited from the client config. */
+    timeout(timeout) {
+        assertValidTimeout.assertValidTimeout(timeout);
+        return this.withConfig({ timeout });
+    }
+    /** Determines whether a response status should be treated as successful. */
+    validateStatus(validateStatus) {
+        assertValidValidateStatus.assertValidValidateStatus(validateStatus);
+        return this.withConfig({ validateStatus });
+    }
+    /** Includes credentials in cross-origin requests. */
+    withCredentials(withCredentials) {
+        assertValidWithCredentials.assertValidWithCredentials(withCredentials);
+        return this.withConfig({ withCredentials });
+    }
+    bearer(token) {
+        assertNonBlankString.assertNonBlankString(token, 'Bearer token must be a non-empty string', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_BEARER_TOKEN);
+        if (headerValueLineBreakPattern.HEADER_VALUE_LINE_BREAK_PATTERN.test(token)) {
+            throw new RequestBuilderError.RequestBuilderError('Bearer token must not contain line breaks', requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_BEARER_TOKEN);
+        }
+        return this.header('Authorization', `Bearer ${token}`);
+    }
+    asJson() {
+        return this.withConfig({ responseType: httpResponseTypes.HTTP_RESPONSE_TYPES.JSON });
+    }
+    asText() {
+        return this.withConfig({ responseType: httpResponseTypes.HTTP_RESPONSE_TYPES.TEXT });
+    }
+    asBlob() {
+        return this.withConfig({ responseType: httpResponseTypes.HTTP_RESPONSE_TYPES.BLOB });
+    }
+    asArrayBuffer() {
+        return this.withConfig({ responseType: httpResponseTypes.HTTP_RESPONSE_TYPES.ARRAY_BUFFER });
+    }
+    asStream() {
+        return this.withConfig({ responseType: httpResponseTypes.HTTP_RESPONSE_TYPES.STREAM });
+    }
+    execute() {
+        return this.executor(this.build());
+    }
+}
+
+exports.HttpRequestBuilder = HttpRequestBuilder;

package/dist/cjs/errors/AbortError.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var HttpClientError = require('./HttpClientError.cjs');
+
+class AbortError extends HttpClientError.HttpClientError {
+}
+function isAbortError(error) {
+    return error instanceof AbortError;
+}
+
+exports.AbortError = AbortError;
+exports.isAbortError = isAbortError;

package/dist/cjs/errors/HttpClientError.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+/** Base class for all HTTP client errors. Supports catching any client error with a single instanceof check. */
+class HttpClientError extends Error {
+    config;
+    constructor(message, options) {
+        super(message, options);
+        this.name = this.constructor.name;
+        this.config = options?.config;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+function isHttpClientError(error) {
+    return error instanceof HttpClientError;
+}
+
+exports.HttpClientError = HttpClientError;
+exports.isHttpClientError = isHttpClientError;

package/dist/cjs/errors/HttpResponseError.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var HttpClientError = require('./HttpClientError.cjs');
+
+/** Indicates that the server completed the request with a non-2xx status. */
+class HttpResponseError extends HttpClientError.HttpClientError {
+    status;
+    statusText;
+    headers;
+    config;
+    data;
+    constructor(message, status, statusText, headers, config, data, options) {
+        super(message, { ...options, config });
+        this.status = status;
+        this.statusText = statusText;
+        this.headers = headers;
+        this.config = config;
+        this.data = data;
+    }
+}
+function isHttpResponseError(error) {
+    return error instanceof HttpResponseError;
+}
+
+exports.HttpResponseError = HttpResponseError;
+exports.isHttpResponseError = isHttpResponseError;

package/dist/cjs/errors/NetworkError.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var HttpClientError = require('./HttpClientError.cjs');
+
+class NetworkError extends HttpClientError.HttpClientError {
+}
+function isNetworkError(error) {
+    return error instanceof NetworkError;
+}
+
+exports.NetworkError = NetworkError;
+exports.isNetworkError = isNetworkError;

package/dist/cjs/errors/ParseError.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var HttpClientError = require('./HttpClientError.cjs');
+
+/** Indicates that a successful response could not be parsed in the requested format. */
+class ParseError extends HttpClientError.HttpClientError {
+    responseType;
+    raw;
+    constructor(message, options) {
+        super(message, options);
+        this.responseType = options?.responseType;
+        this.raw = options?.raw;
+    }
+}
+function isParseError(error) {
+    return error instanceof ParseError;
+}
+
+exports.ParseError = ParseError;
+exports.isParseError = isParseError;

package/dist/cjs/errors/RequestBuilderError.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var requestBuilderErrorCodes = require('../constants/requestBuilderErrorCodes.cjs');
+var HttpClientError = require('./HttpClientError.cjs');
+
+class RequestBuilderError extends HttpClientError.HttpClientError {
+    code;
+    constructor(message, code = requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES.INVALID_CONFIG) {
+        super(message);
+        this.code = code;
+    }
+}
+function isRequestBuilderError(error) {
+    return error instanceof RequestBuilderError;
+}
+
+exports.RequestBuilderError = RequestBuilderError;
+exports.isRequestBuilderError = isRequestBuilderError;

package/dist/cjs/errors/RequestPreparationError.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var HttpClientError = require('./HttpClientError.cjs');
+
+/** Indicates that an adapter could not prepare a request before sending it. */
+class RequestPreparationError extends HttpClientError.HttpClientError {
+}
+function isRequestPreparationError(error) {
+    return error instanceof RequestPreparationError;
+}
+
+exports.RequestPreparationError = RequestPreparationError;
+exports.isRequestPreparationError = isRequestPreparationError;

package/dist/cjs/errors/TimeoutError.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var HttpClientError = require('./HttpClientError.cjs');
+
+/** Indicates that the request exceeded the configured timeout. */
+class TimeoutError extends HttpClientError.HttpClientError {
+    timeout;
+    constructor(message, options) {
+        super(message, options);
+        this.timeout = options?.timeout;
+    }
+}
+function isTimeoutError(error) {
+    return error instanceof TimeoutError;
+}
+
+exports.TimeoutError = TimeoutError;
+exports.isTimeoutError = isTimeoutError;

package/dist/cjs/index.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var HttpClient = require('./core/HttpClient.cjs');
+var HttpRequestBuilder = require('./core/HttpRequestBuilder.cjs');
+var FetchAdapter = require('./adapters/FetchAdapter.cjs');
+var XhrAdapter = require('./adapters/XhrAdapter.cjs');
+var httpMethods = require('./constants/httpMethods.cjs');
+var httpStatusCodes = require('./constants/httpStatusCodes.cjs');
+var httpResponseTypes = require('./constants/httpResponseTypes.cjs');
+var requestBuilderErrorCodes = require('./constants/requestBuilderErrorCodes.cjs');
+var AbortError = require('./errors/AbortError.cjs');
+var HttpClientError = require('./errors/HttpClientError.cjs');
+var HttpResponseError = require('./errors/HttpResponseError.cjs');
+var NetworkError = require('./errors/NetworkError.cjs');
+var ParseError = require('./errors/ParseError.cjs');
+var RequestBuilderError = require('./errors/RequestBuilderError.cjs');
+var RequestPreparationError = require('./errors/RequestPreparationError.cjs');
+var TimeoutError = require('./errors/TimeoutError.cjs');
+
+
+
+exports.HttpClient = HttpClient.HttpClient;
+exports.HttpRequestBuilder = HttpRequestBuilder.HttpRequestBuilder;
+exports.FetchAdapter = FetchAdapter.FetchAdapter;
+exports.XhrAdapter = XhrAdapter.XhrAdapter;
+exports.HTTP_METHODS = httpMethods.HTTP_METHODS;
+exports.HTTP_STATUS_CODES = httpStatusCodes.HTTP_STATUS_CODES;
+exports.HTTP_RESPONSE_TYPES = httpResponseTypes.HTTP_RESPONSE_TYPES;
+exports.REQUEST_BUILDER_ERROR_CODES = requestBuilderErrorCodes.REQUEST_BUILDER_ERROR_CODES;
+exports.AbortError = AbortError.AbortError;
+exports.isAbortError = AbortError.isAbortError;
+exports.HttpClientError = HttpClientError.HttpClientError;
+exports.isHttpClientError = HttpClientError.isHttpClientError;
+exports.HttpResponseError = HttpResponseError.HttpResponseError;
+exports.isHttpResponseError = HttpResponseError.isHttpResponseError;
+exports.NetworkError = NetworkError.NetworkError;
+exports.isNetworkError = NetworkError.isNetworkError;
+exports.ParseError = ParseError.ParseError;
+exports.isParseError = ParseError.isParseError;
+exports.RequestBuilderError = RequestBuilderError.RequestBuilderError;
+exports.isRequestBuilderError = RequestBuilderError.isRequestBuilderError;
+exports.RequestPreparationError = RequestPreparationError.RequestPreparationError;
+exports.isRequestPreparationError = RequestPreparationError.isRequestPreparationError;
+exports.TimeoutError = TimeoutError.TimeoutError;
+exports.isTimeoutError = TimeoutError.isTimeoutError;

package/dist/cjs/utilities/buildUrl.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+function splitUrl(value) {
+    const hashIndex = value.indexOf('#');
+    const beforeHash = hashIndex === -1 ? value : value.slice(0, hashIndex);
+    const hash = hashIndex === -1 ? '' : value.slice(hashIndex);
+    const queryIndex = beforeHash.indexOf('?');
+    return {
+        path: queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex),
+        query: queryIndex === -1 ? '' : beforeHash.slice(queryIndex + 1),
+        hash
+    };
+}
+function joinPaths(basePath, path) {
+    if (!path) {
+        return basePath;
+    }
+    if (!basePath) {
+        return path;
+    }
+    return `${basePath.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+function getAbsoluteUrl(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function serializeParams(params) {
+    if (params === undefined) {
+        return '';
+    }
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        const values = Array.isArray(value) ? value : [value];
+        for (const item of values) {
+            if (item === null || item === undefined) {
+                continue;
+            }
+            searchParams.append(key, String(item));
+        }
+    }
+    return searchParams.toString();
+}
+function appendParams(url, params) {
+    const query = serializeParams(params);
+    if (!query) {
+        return url;
+    }
+    const { path, query: existingQuery, hash } = splitUrl(url);
+    const combinedQuery = [existingQuery, query].filter(Boolean).join('&');
+    return `${path}?${combinedQuery}${hash}`;
+}
+function resolveRelativeUrl(baseUrl, url) {
+    const base = splitUrl(baseUrl);
+    const request = splitUrl(url);
+    const query = [base.query, request.query].filter(Boolean).join('&');
+    return `${joinPaths(base.path, request.path)}${query ? `?${query}` : ''}${request.hash}`;
+}
+function resolveAbsoluteUrl(base, url) {
+    const request = splitUrl(url);
+    base.pathname = joinPaths(base.pathname, request.path);
+    base.hash = request.hash;
+    if (request.query) {
+        const requestParams = new URLSearchParams(request.query);
+        requestParams.forEach((value, key) => {
+            base.searchParams.append(key, value);
+        });
+    }
+    return base.toString();
+}
+/**
+ * Resolves a request URL against an optional base URL, preserves existing query values and fragments,
+ * and appends serialized params before the fragment.
+ */
+function buildUrl(baseUrl, url, params) {
+    const absoluteUrl = getAbsoluteUrl(url);
+    if (absoluteUrl !== undefined) {
+        return appendParams(absoluteUrl.toString(), params);
+    }
+    if (baseUrl === undefined) {
+        return appendParams(url, params);
+    }
+    const absoluteBaseUrl = getAbsoluteUrl(baseUrl);
+    const fullUrl = absoluteBaseUrl === undefined ? resolveRelativeUrl(baseUrl, url) : resolveAbsoluteUrl(absoluteBaseUrl, url);
+    return appendParams(fullUrl, params);
+}
+
+exports.buildUrl = buildUrl;

package/dist/cjs/utilities/getErrorMessage.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+/** Returns a non-empty Error message or the provided fallback for unknown error values. */
+function getErrorMessage(error, fallback) {
+    return error instanceof Error && error.message ? error.message : fallback;
+}
+
+exports.getErrorMessage = getErrorMessage;

package/dist/cjs/utilities/isStatusAccepted.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+/** Applies a custom status predicate or accepts the standard successful HTTP status range. */
+function isStatusAccepted(status, validateStatus) {
+    return validateStatus === undefined ? status >= 200 && status < 300 : validateStatus(status);
+}
+
+exports.isStatusAccepted = isStatusAccepted;

package/dist/cjs/utilities/mergeHeaders.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+/** Merges header maps from left to right using case-insensitive names while preserving the latest name casing. */
+function mergeHeaders(...sources) {
+    const result = {};
+    const normalizedKeys = new Map();
+    for (const source of sources) {
+        if (source === undefined) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(source)) {
+            const normalizedKey = key.toLowerCase();
+            const previousKey = normalizedKeys.get(normalizedKey);
+            if (previousKey !== undefined) {
+                delete result[previousKey];
+            }
+            result[key] = value;
+            normalizedKeys.set(normalizedKey, key);
+        }
+    }
+    return result;
+}
+/** Checks whether a header map contains a name using case-insensitive comparison. */
+function hasHeader(headers, name) {
+    const normalizedName = name.toLowerCase();
+    return Object.keys(headers).some(key => key.toLowerCase() === normalizedName);
+}
+
+exports.hasHeader = hasHeader;
+exports.mergeHeaders = mergeHeaders;

package/dist/cjs/utilities/mergeParams.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+function isPresentParamPrimitive(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Merges query params from left to right. `null` / `undefined` remove a key; nullish array items are dropped.
+ * Returns undefined when no params remain.
+ */
+function mergeParams(...sources) {
+    const result = {};
+    for (const source of sources) {
+        if (source === undefined) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(source)) {
+            if (value === null || value === undefined) {
+                delete result[key];
+                continue;
+            }
+            if (Array.isArray(value)) {
+                const items = value.filter(isPresentParamPrimitive);
+                if (items.length === 0) {
+                    delete result[key];
+                }
+                else {
+                    result[key] = [...items];
+                }
+                continue;
+            }
+            result[key] = value;
+        }
+    }
+    return Object.keys(result).length === 0 ? undefined : result;
+}
+
+exports.mergeParams = mergeParams;