@ethlete/query 0.1.0-next.9 → 1.0.1

package/fesm2020/ethlete-query.mjs

@@ -1,40 +1,60 @@
-import { Subject, timer, filter, takeWhile, BehaviorSubject, interval, takeUntil, tap, switchMap, of, fromEvent, startWith, concat, take, debounceTime, combineLatest, map, distinctUntilChanged } from 'rxjs';
+import { getCookie, setCookie, deleteCookie, DestroyService, equal, clone } from '@ethlete/core';
+import { Observable, filter, takeWhile, switchMap, of, BehaviorSubject, Subject, takeUntil, interval, tap, timer, fromEvent, startWith, concat, take, debounceTime, combineLatest, map, distinctUntilChanged } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Directive, Input, InjectionToken, inject, ChangeDetectorRef, ViewContainerRef, TemplateRef, ErrorHandler, ElementRef } from '@angular/core';
-import * as i1 from '@ethlete/core';
-import { DestroyDirective } from '@ethlete/core';
 import { FormGroup } from '@angular/forms';
 import { Router, ActivatedRoute } from '@angular/router';
 
 class CustomHeaderAuthProvider {
-    constructor(_config) {
-        this._config = _config;
-        this.queryClient = null;
-    }
     get header() {
         return { [this._config.name]: this._config.value };
     }
+    constructor(_config) {
+        this._config = _config;
+    }
     cleanUp() {
         // noop
     }
 }
 
 class BasicAuthProvider {
-    constructor(_config) {
-        this._config = _config;
-        this.queryClient = null;
-    }
     get header() {
         return { Authorization: `Basic ${this._basicAuthString}` };
     }
     get _basicAuthString() {
         return btoa(`${this._config.username}:${this._config.password}`);
     }
+    constructor(_config) {
+        this._config = _config;
+    }
     cleanUp() {
         // noop
     }
 }
 
+const getOpName = /(query|mutation) ?([\w\d-_]+)? ?\(.*?\)? \{/;
+const transformGql = (str) => {
+    str = Array.isArray(str) ? str.join('') : str;
+    const name = getOpName.exec(str);
+    return function (variables) {
+        const data = { query: str };
+        if (variables)
+            data['variables'] = JSON.stringify(variables);
+        if (name && name.length) {
+            const operationName = name[2];
+            if (operationName)
+                data['operationName'] = name[2];
+        }
+        return data;
+    };
+};
+const gql = (strings, ...values) => {
+    const str = strings.reduce((acc, cur, i) => {
+        return acc + cur + (values[i] || '');
+    }, '');
+    return str;
+};
+
 const buildErrorMessage = (code, message) => `[@ethlete\\query:${code}] ${message}`;
 class QueryError extends Error {
     constructor(code, message, data) {
@@ -52,7 +72,6 @@ const queryStateCannotTransformError = (data) => new QueryError('006', 'The quer
 const invalidBodyError = (data) => new QueryError('007', 'The body is not valid or upsupported', data);
 
 const isRequestError = (error) => error instanceof Object && 'code' in error && 'message' in error;
-const isAbortRequestError = (error) => isRequestError(error) && error.code === -1;
 const buildRoute = (options) => {
     if (options.base.endsWith('/')) {
         throw invalidBaseRouteError(options.base);
@@ -125,9 +144,9 @@ const isParamValid = (primitive) => {
     return true;
 };
 const extractExpiresInSeconds = (headers) => {
-    const cacheControl = headers.get('cache-control');
-    const age = headers.get('age');
-    const expires = headers.get('expires');
+    const cacheControl = headers['cache-control'];
+    const age = headers['age'];
+    const expires = headers['expires'];
     // In seconds
     let expiresIn = null;
     let maxAge = null;
@@ -166,91 +185,21 @@ const buildTimestampFromSeconds = (seconds) => {
     }
     return new Date(Date.now() + seconds * 1000).getTime();
 };
-const buildRequestError = async (error, route, requestInit) => {
-    if (error instanceof DOMException && error.code === error.ABORT_ERR) {
-        const err = {
-            code: -1,
-            message: 'Request aborted',
-            detail: null,
-            raw: error,
-            route,
-            requestInit,
-        };
-        return err;
-    }
-    if (error instanceof SyntaxError) {
-        const err = {
-            code: -3,
-            message: 'Syntax error',
-            detail: null,
-            raw: error,
-            route,
-            requestInit,
-        };
-        return err;
-    }
-    if (error instanceof Error) {
-        const err = {
-            code: -2,
-            message: `${error.name}: ${error.message}`,
-            detail: null,
-            raw: error,
-            route,
-            requestInit,
-        };
-        return err;
-    }
-    if (isFetchResponse(error)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let detail = null;
-        try {
-            detail = await error.json();
-        }
-        catch {
-            // noop
-        }
-        if (!detail) {
-            try {
-                detail = await error.text();
-            }
-            catch {
-                // noop
-            }
-        }
-        const err = {
-            code: error.status,
-            message: error.statusText,
-            detail,
-            raw: error,
-            route,
-            requestInit,
-        };
-        return err;
-    }
-    const err = {
-        code: 0,
-        message: 'Unknown error',
-        detail: null,
-        raw: error,
-        route,
-        requestInit,
-    };
-    return err;
-};
-const buildBody = (body) => {
-    if (body === undefined || body === null) {
+const serializeBody = (body) => {
+    if (body === null || body === undefined) {
         return null;
     }
-    if (typeof body === 'string') {
+    if (body instanceof ArrayBuffer ||
+        body instanceof Blob ||
+        body instanceof FormData ||
+        body instanceof URLSearchParams ||
+        typeof body === 'string') {
         return body;
     }
-    if (typeof body === 'object') {
+    if (typeof body === 'object' || typeof body === 'boolean' || Array.isArray(body)) {
         return JSON.stringify(body);
     }
-    if (body instanceof FormData) {
-        return body;
-    }
-    throw invalidBodyError(body);
+    return body.toString();
 };
 const transformMethod = (method) => {
     if (method === 'GQL_QUERY' || method === 'GQL_MUTATE') {
@@ -258,192 +207,236 @@ const transformMethod = (method) => {
     }
     return method;
 };
-const guessContentType = (body) => {
-    if (body === null || body === undefined) {
+const detectContentTypeHeader = (body) => {
+    // An empty body has no content type.
+    if (body === null) {
+        return null;
+    }
+    // FormData bodies rely on the browser's content type assignment.
+    if (body instanceof FormData) {
         return null;
     }
+    // Blobs usually have their own content type. If it doesn't, then
+    // no type can be inferred.
+    if (body instanceof Blob) {
+        return body.type || null;
+    }
+    // Array buffers have unknown contents and thus no type can be inferred.
+    if (body instanceof ArrayBuffer) {
+        return null;
+    }
+    // Technically, strings could be a form of JSON data, but it's safe enough
+    // to assume they're plain strings.
     if (typeof body === 'string') {
         return 'text/plain';
     }
-    if (body instanceof FormData) {
-        return 'multipart/form-data';
-    }
-    if (typeof body === 'object') {
+    // Arrays, objects, boolean and numbers will be encoded as JSON.
+    if (typeof body === 'object' || typeof body === 'number' || typeof body === 'boolean') {
         return 'application/json';
     }
+    // No type could be inferred.
     return null;
 };
-
-const request = async (options) => {
-    try {
-        const response = await fetch(options.route, options.init);
-        if (!response.ok) {
-            throw response;
-        }
-        const isJsonResponse = response.headers.get('Content-Type')?.includes('application/json');
-        const isTextResponse = response.headers.get('Content-Type')?.includes('text/plain');
-        const data = (isJsonResponse ? await response.json() : isTextResponse ? await response.text() : null);
-        const expiresInSeconds = options.cacheAdapter
-            ? options.cacheAdapter(response.headers)
-            : extractExpiresInSeconds(response.headers);
-        const expiresInTimestamp = buildTimestampFromSeconds(expiresInSeconds);
-        return { data, expiresInTimestamp };
-    }
-    catch (error) {
-        throw await buildRequestError(error, options.route, options.init);
-    }
+const hasHeader = (headers, header) => {
+    return Object.keys(headers).some((key) => key.toLowerCase() === header.toLowerCase());
 };
-
-const isBasicAuthProvider = (authProvider) => authProvider instanceof BasicAuthProvider;
-const isBearerAuthProvider = (authProvider) => authProvider instanceof BearerAuthProvider;
-const isCustomHeaderAuthProvider = (authProvider) => authProvider instanceof CustomHeaderAuthProvider;
-const decryptBearer = (token) => {
-    try {
-        const base64Url = token.split('.')[1];
-        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
-        const jsonPayload = decodeURIComponent(atob(base64)
-            .split('')
-            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
-            .join(''));
-        return JSON.parse(jsonPayload);
-    }
-    catch (error) {
-        console.error(`Invalid bearer token: ${token}`, error);
-        return null;
-    }
+const forEachHeader = (headers, callback) => {
+    Object.entries(headers).forEach(([key, value]) => {
+        callback(key, value);
+    });
 };
-
-class BearerAuthProvider {
-    constructor(_config) {
-        this._config = _config;
-        this._refreshToken = null;
-        this._refreshTimerSubscription = null;
-        this.queryClient = null;
-        this.onRefreshInitiation$ = new Subject();
-        this.onRefreshSuccess$ = new Subject();
-        this.onRefreshFailure$ = new Subject();
-        this._token = _config.token;
-        this._refreshToken = _config.refreshConfig?.token ?? null;
-        if (this._config.refreshConfig) {
-            this._setupRefresh(this._config.refreshConfig);
+const parseAllXhrResponseHeaders = (xhr) => {
+    const headers = xhr.getAllResponseHeaders();
+    const parsedHeaders = {};
+    for (const line of headers.split('\n')) {
+        const index = line.indexOf(':');
+        if (index > 0) {
+            const name = line.slice(0, index);
+            const key = name.toLowerCase();
+            const value = line.slice(index + 1).trim();
+            parsedHeaders[key] = value;
         }
     }
-    get header() {
-        return { Authorization: `Bearer ${this._token}` };
+    return parsedHeaders;
+};
+const getResponseUrl = (xhr) => {
+    if ('responseURL' in xhr && xhr.responseURL) {
+        return xhr.responseURL;
     }
-    cleanUp() {
-        this._refreshTimerSubscription?.unsubscribe();
-        this._refreshTimerSubscription = null;
+    if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
+        return xhr.getResponseHeader('X-Request-URL');
     }
-    _setupRefresh(config) {
-        const bearer = decryptBearer(this._token);
-        if (!bearer) {
-            return;
-        }
-        const expiresInPropertyName = config.expiresInPropertyName || 'exp';
-        const expiresIn = bearer[expiresInPropertyName];
-        const fiveMinutes = 5 * 60 * 1000;
-        if (expiresIn === undefined) {
-            throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);
-        }
-        const remainingTime = new Date(expiresIn * 1000).getTime() - fiveMinutes - new Date().getTime();
-        const strategy = config.strategy ?? "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */;
-        switch (strategy) {
-            case "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */:
-                this._refreshTimerSubscription = timer(remainingTime).subscribe(() => this._refresh(config));
-                break;
+    return null;
+};
+
+const XSSI_PREFIX = /^\)\]\}',?\n/;
+const request = (config) => {
+    const headers = config.headers || {};
+    const responseType = config.responseType || 'json';
+    const body = config.body || null;
+    const url = config.urlWithParams.split('?')[0];
+    return new Observable((observer) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open(config.method, config.urlWithParams);
+        if (config.withCredentials) {
+            xhr.withCredentials = true;
         }
-    }
-    async _refresh(config) {
-        if (!this._refreshToken) {
-            throw new Error('No refresh token found');
+        forEachHeader(headers, (name, value) => xhr.setRequestHeader(name, value));
+        if (!hasHeader(headers, 'Accept')) {
+            xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
         }
-        if (!this.queryClient) {
-            throw new Error('Query client instance is null');
+        if (!hasHeader(headers, 'Content-Type')) {
+            const detectedType = detectContentTypeHeader(body);
+            if (detectedType) {
+                xhr.setRequestHeader('Content-Type', detectedType);
+            }
         }
-        const { method, route, bodyAdapter, responseAdapter } = config;
-        const fullRoute = buildRoute({
-            base: this.queryClient.config.baseRoute,
-            route,
-        });
-        const body = bodyAdapter ? bodyAdapter(this._refreshToken) : { refreshToken: this._refreshToken };
-        const requestInit = { body: buildBody(body), method };
-        this.onRefreshInitiation$.next();
-        try {
-            const result = await request({
-                route: fullRoute,
-                init: requestInit,
-            });
-            const tokens = responseAdapter ? responseAdapter(result.data) : result.data;
-            if (!tokens.token) {
-                throw new Error('Token not found in response');
+        xhr.responseType = responseType !== 'json' ? responseType : 'text';
+        const reqBody = serializeBody(body);
+        let headerResponse = null;
+        const partialFromXhr = () => {
+            if (headerResponse !== null) {
+                return headerResponse;
             }
-            if (!tokens.refreshToken) {
-                throw new Error('Refresh token not found in response');
+            const statusText = xhr.statusText || 'OK';
+            const headers = parseAllXhrResponseHeaders(xhr);
+            const _url = getResponseUrl(xhr) || url;
+            headerResponse = { headers, status: xhr.status, statusText, url: _url };
+            return headerResponse;
+        };
+        const onLoad = () => {
+            const { headers, statusText, url } = partialFromXhr();
+            let { status } = partialFromXhr();
+            let body = null;
+            if (status !== 204 /* HttpStatusCode.NoContent */) {
+                body = typeof xhr.response === 'undefined' ? xhr.responseText : xhr.response;
             }
-            this._token = tokens.token;
-            this._refreshToken = tokens.refreshToken;
-            this.onRefreshSuccess$.next(tokens);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                this.onRefreshFailure$.next(await buildRequestError(error, fullRoute, requestInit));
+            if (status === 0) {
+                status = body ? 200 /* HttpStatusCode.Ok */ : 0;
+            }
+            let ok = status >= 200 && status < 300;
+            if (responseType === 'json' && typeof body === 'string') {
+                const originalBody = body;
+                body = body.replace(XSSI_PREFIX, '');
+                try {
+                    body = body !== '' ? JSON.parse(body) : null;
+                }
+                catch (error) {
+                    body = originalBody;
+                    if (ok) {
+                        ok = false;
+                        body = { error, text: body };
+                    }
+                }
+            }
+            if (ok) {
+                const successEvent = {
+                    type: 'success',
+                    headers,
+                    response: body,
+                };
+                const expiresInSeconds = config.cacheAdapter?.(headers) ?? extractExpiresInSeconds(headers);
+                const expiresInTimestamp = buildTimestampFromSeconds(expiresInSeconds);
+                if (expiresInTimestamp) {
+                    successEvent.expiresInTimestamp = expiresInTimestamp;
+                }
+                observer.next(successEvent);
+                observer.complete();
             }
             else {
-                this.onRefreshFailure$.next(error);
+                observer.next({
+                    type: 'failure',
+                    headers,
+                    error: {
+                        url,
+                        detail: body,
+                        status,
+                        statusText,
+                    },
+                });
+                observer.complete();
+            }
+        };
+        const onError = (error) => {
+            const { url, headers } = partialFromXhr();
+            observer.next({
+                type: 'failure',
+                headers,
+                error: {
+                    url,
+                    detail: error,
+                    status: xhr.status || 0,
+                    statusText: xhr.statusText || 'Unknown Error',
+                },
+            });
+            observer.complete();
+        };
+        const onDownProgress = (event) => {
+            const { headers } = partialFromXhr();
+            const progress = {
+                type: 'download-progress',
+                headers,
+                progress: {
+                    current: event.loaded,
+                },
+            };
+            if (event.lengthComputable) {
+                const progressPercent = (event.loaded / event.total) * 100;
+                progress.progress.percentage = Math.round(progressPercent * 100) / 100;
+                progress.progress.total = event.total;
+            }
+            if (responseType === 'text' && !!xhr.responseText) {
+                progress.partialText = xhr.responseText;
+            }
+            observer.next(progress);
+        };
+        const onUpProgress = (event) => {
+            const { headers } = partialFromXhr();
+            const progress = {
+                type: 'upload-progress',
+                headers,
+                progress: {
+                    current: event.loaded,
+                },
+            };
+            if (event.lengthComputable) {
+                const progressPercent = (event.loaded / event.total) * 100;
+                progress.progress.percentage = Math.round(progressPercent * 100) / 100;
+                progress.progress.total = event.total;
+            }
+            observer.next(progress);
+        };
+        xhr.addEventListener('load', onLoad);
+        xhr.addEventListener('error', onError);
+        xhr.addEventListener('timeout', onError);
+        xhr.addEventListener('abort', onError);
+        if (config.reportProgress) {
+            xhr.addEventListener('progress', onDownProgress);
+            if (reqBody !== null && xhr.upload) {
+                xhr.upload.addEventListener('progress', onUpProgress);
             }
         }
-    }
-}
-
-const getOpName = /(query|mutation) ?([\w\d-_]+)? ?\(.*?\)? \{/;
-const transformGql = (str) => {
-    str = Array.isArray(str) ? str.join('') : str;
-    const name = getOpName.exec(str);
-    return function (variables) {
-        const data = { query: str };
-        if (variables)
-            data['variables'] = JSON.stringify(variables);
-        if (name && name.length) {
-            const operationName = name[2];
-            if (operationName)
-                data['operationName'] = name[2];
-        }
-        return JSON.stringify(data);
-    };
-};
-const gql = (strings, ...values) => {
-    const str = strings.reduce((acc, cur, i) => {
-        return acc + cur + (values[i] || '');
-    }, '');
-    return str;
-};
-
-const deepFreeze = (object) => {
-    // check if object is actually an object or frozen
-    if (!object || typeof object !== 'object' || Object.isFrozen(object)) {
-        return object;
-    }
-    // Retrieve the property names defined on object
-    const propNames = Object.getOwnPropertyNames(object);
-    // Freeze properties before freezing self
-    for (const name of propNames) {
-        const value = object[name];
-        if (value && typeof value === 'object') {
-            deepFreeze(value);
-        }
-    }
-    return Object.freeze(object);
+        xhr.send(reqBody);
+        observer.next({ type: 'start', headers });
+        return () => {
+            xhr.removeEventListener('error', onError);
+            xhr.removeEventListener('abort', onError);
+            xhr.removeEventListener('load', onLoad);
+            xhr.removeEventListener('timeout', onError);
+            if (config.reportProgress) {
+                xhr.removeEventListener('progress', onDownProgress);
+                if (reqBody !== null && xhr.upload) {
+                    xhr.upload.removeEventListener('progress', onUpProgress);
+                }
+            }
+            if (xhr.readyState !== xhr.DONE) {
+                xhr.abort();
+            }
+            observer.next({ type: 'cancel', headers });
+        };
+    });
 };
 
-/**
- * Dummy function for providing types while not breaking inference.
- * **This function always returns null.**
- * @see https://github.com/microsoft/TypeScript/issues/26242
- * @returns null
- */
-const def = () => null;
-
 function filterSuccess() {
     return function (source) {
         return source.pipe(filter((value) => isQueryStateSuccess(value)));
@@ -454,9 +447,34 @@ function filterFailure() {
         return source.pipe(filter((value) => isQueryStateFailure(value)));
     };
 }
-function takeUntilResponse() {
+function filterQueryStates(allowedStates) {
     return function (source) {
-        return source.pipe(takeWhile((value) => isQueryStateLoading(value), true));
+        return source.pipe(filter((value) => value && allowedStates.includes(value.type)));
+    };
+}
+function takeUntilResponse(config) {
+    return function (source) {
+        return source.pipe(takeWhile((value) => {
+            if (config?.excludeNull && value === null) {
+                return false;
+            }
+            return isQueryStateLoading(value) || value === null;
+        }, true));
+    };
+}
+function filterNull() {
+    return function (source) {
+        return source.pipe(filter((value) => value !== null));
+    };
+}
+function switchQueryState() {
+    return function (source) {
+        return source.pipe(switchMap((value) => value?.state$ ?? of(null)));
+    };
+}
+function switchQueryCollectionState() {
+    return function (source) {
+        return source.pipe(switchMap((value) => value?.query.state$ ?? of(null)));
     };
 }
 const isQueryStateLoading = (state) => state?.type === "LOADING" /* QueryStateType.Loading */;
@@ -484,23 +502,32 @@ const isGqlQueryConfig = (config) => {
     }
     return true;
 };
+const isQuery = (query) => {
+    if (!query || typeof query !== 'object' || Array.isArray(query)) {
+        return false;
+    }
+    if (!('state$' in query)) {
+        return false;
+    }
+    return true;
+};
+const createQueryCollection = (
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+queryMap) => new BehaviorSubject(null);
+const extractQuery = (v) => (isQuery(v) ? v : v?.query) ?? null;
+const getDefaultHeaders = (headers, method) => {
+    if (!headers) {
+        return {};
+    }
+    if (method in headers) {
+        return (headers[method] ?? {});
+    }
+    return headers;
+};
 
 class Query {
-    constructor(_client, _queryConfig, _route, _args) {
-        this._client = _client;
-        this._queryConfig = _queryConfig;
-        this._route = _route;
-        this._args = _args;
-        this._currentId = 0;
-        this._abortController = new AbortController();
-        this._pollingSubscription = null;
-        this._state$ = new BehaviorSubject({
-            type: "PREPARED" /* QueryStateType.Prepared */,
-            meta: { id: this._currentId },
-        });
-    }
     get _nextId() {
-        return this._currentId++;
+        return ++this._currentId;
     }
     get state$() {
         return this._state$.asObservable();
@@ -518,6 +545,19 @@ class Query {
         }
         return ts < Date.now();
     }
+    constructor(_client, _queryConfig, _routeWithParams, _args) {
+        this._client = _client;
+        this._queryConfig = _queryConfig;
+        this._routeWithParams = _routeWithParams;
+        this._args = _args;
+        this._currentId = 0;
+        this._pollingSubscription = null;
+        this._onAbort$ = new Subject();
+        this._state$ = new BehaviorSubject({
+            type: "PREPARED" /* QueryStateType.Prepared */,
+            meta: { id: this._currentId },
+        });
+    }
     clone() {
         return this._client.fetch(this._queryConfig);
     }
@@ -532,22 +572,20 @@ class Query {
         if (isQueryStateLoading(this._state$.value)) {
             this.abort();
         }
-        const meta = deepFreeze({ id });
+        const meta = { id };
         this._state$.next({
             type: "LOADING" /* QueryStateType.Loading */,
             meta,
         });
-        let body = null;
-        let contentType = null;
+        this._updateUseResultInDependencies();
+        let body;
         if (isGqlQueryConfig(this._queryConfig)) {
             const queryTemplate = this._queryConfig.query;
             const query = transformGql(queryTemplate);
-            contentType = 'application/json';
             body = query(this._args?.variables);
         }
         else {
-            body = buildBody(this._args?.body);
-            contentType = guessContentType(this._args?.body);
+            body = this._args?.body;
         }
         let authHeader = null;
         if (this._queryConfig.secure) {
@@ -561,57 +599,83 @@ class Query {
                 authHeader = this._client.authProvider.header;
             }
         }
-        let headers = mergeHeaders(authHeader, this._args?.headers);
-        if (contentType && !headers?.['Content-Type'] && !headers?.['content-type']) {
-            if (headers) {
-                headers['Content-Type'] = contentType;
-            }
-            else {
-                headers = {
-                    'Content-Type': contentType,
-                };
-            }
-        }
         request({
-            route: this._route,
-            init: {
-                method: transformMethod(this._queryConfig.method),
-                signal: this._abortController.signal,
-                body,
-                headers: headers || undefined,
-            },
+            urlWithParams: this._routeWithParams,
+            method: transformMethod(this._queryConfig.method),
+            body,
+            headers: mergeHeaders(getDefaultHeaders(this._client.config.request?.headers, this._queryConfig.method), authHeader, this._args?.headers) || undefined,
             cacheAdapter: this._client.config.request?.cacheAdapter,
+            reportProgress: this._queryConfig.reportProgress,
+            responseType: this._queryConfig.responseType,
+            withCredentials: this._queryConfig.withCredentials,
         })
-            .then((response) => {
-            const isResponseObject = typeof response === 'object';
-            const isGql = isGqlQueryConfig(this._queryConfig);
-            let responseData = null;
-            if (isGql &&
-                isResponseObject &&
-                !!response.data &&
-                typeof response.data === 'object' &&
-                'data' in response.data) {
-                responseData = response.data['data'];
-            }
-            else {
-                responseData = response.data;
-            }
-            const transformedResponse = this._queryConfig.responseTransformer
-                ? this._queryConfig.responseTransformer(responseData)
-                : responseData;
-            this._state$.next({
-                type: "SUCCESS" /* QueryStateType.Success */,
-                response: deepFreeze(transformedResponse),
-                rawResponse: deepFreeze(responseData),
-                meta: deepFreeze({ ...meta, expiresAt: response.expiresInTimestamp }),
-            });
-        })
-            .catch((error) => this._handleExecuteError(error, meta));
+            .pipe(takeUntil(this._onAbort$))
+            .subscribe({
+            next: (state) => {
+                if (state.type === 'start') {
+                    this._state$.next({
+                        type: "LOADING" /* QueryStateType.Loading */,
+                        meta,
+                    });
+                }
+                else if (state.type === 'download-progress') {
+                    this._state$.next({
+                        type: "LOADING" /* QueryStateType.Loading */,
+                        progress: state.progress,
+                        partialText: state.partialText,
+                        meta,
+                    });
+                }
+                else if (state.type === 'upload-progress') {
+                    this._state$.next({
+                        type: "LOADING" /* QueryStateType.Loading */,
+                        progress: state.progress,
+                        meta,
+                    });
+                }
+                else if (state.type === 'success') {
+                    const isResponseObject = typeof state.response === 'object';
+                    const isGql = isGqlQueryConfig(this._queryConfig);
+                    let responseData = null;
+                    if (isGql &&
+                        isResponseObject &&
+                        !!state.response &&
+                        typeof state.response === 'object' &&
+                        'data' in state.response) {
+                        responseData = state.response['data'];
+                    }
+                    else {
+                        responseData = state.response;
+                    }
+                    const transformedResponse = this._queryConfig.responseTransformer
+                        ? this._queryConfig.responseTransformer(responseData)
+                        : responseData;
+                    this._state$.next({
+                        type: "SUCCESS" /* QueryStateType.Success */,
+                        rawResponse: state.response,
+                        response: transformedResponse,
+                        meta: { ...meta, expiresAt: state.expiresInTimestamp },
+                    });
+                }
+                else if (state.type === 'failure') {
+                    this._state$.next({
+                        type: "FAILURE" /* QueryStateType.Failure */,
+                        error: state.error,
+                        meta,
+                    });
+                }
+                else if (state.type === 'cancel') {
+                    this._state$.next({
+                        type: "CANCELLED" /* QueryStateType.Cancelled */,
+                        meta,
+                    });
+                }
+            },
+        });
         return this;
     }
     abort() {
-        this._abortController.abort();
-        this._abortController = new AbortController();
+        this._onAbort$.next();
         return this;
     }
     poll(config) {
@@ -628,27 +692,200 @@ class Query {
         this._pollingSubscription = null;
         return this;
     }
-    _handleExecuteError(error, meta) {
-        if (isAbortRequestError(error)) {
-            this._state$.next({
-                type: "CANCELLED" /* QueryStateType.Cancelled */,
-                meta,
-            });
+    _updateUseResultInDependencies() {
+        if (!this._args?.useResultIn?.length) {
+            return;
         }
-        else if (isRequestError(error)) {
-            this._state$.next({
-                type: "FAILURE" /* QueryStateType.Failure */,
-                error,
-                meta,
-            });
+        this.state$
+            .pipe(filterSuccess(), takeUntil(this._onAbort$), takeUntilResponse(), tap((state) => {
+            if (!this._args?.useResultIn) {
+                return;
+            }
+            for (const query of this._args.useResultIn) {
+                query._state$.next({
+                    type: "SUCCESS" /* QueryStateType.Success */,
+                    meta: { ...state.meta, id: query._nextId },
+                    rawResponse: state.rawResponse,
+                    response: state.response,
+                });
+            }
+        }))
+            .subscribe();
+    }
+}
+
+const isBasicAuthProvider = (authProvider) => authProvider instanceof BasicAuthProvider;
+const isBearerAuthProvider = (authProvider) => authProvider instanceof BearerAuthProvider;
+const isCustomHeaderAuthProvider = (authProvider) => authProvider instanceof CustomHeaderAuthProvider;
+const decryptBearer = (token) => {
+    try {
+        const base64Url = token.split('.')[1];
+        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split('')
+            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch (error) {
+        console.error(`Invalid bearer token: ${token}`, error);
+        return null;
+    }
+};
+
+class BearerAuthProvider {
+    get header() {
+        return { Authorization: `Bearer ${this._tokens$.getValue().token}` };
+    }
+    get tokens$() {
+        return this._tokens$.asObservable();
+    }
+    get tokens() {
+        return this._tokens$.getValue();
+    }
+    get currentRefreshQuery$() {
+        return this._currentRefreshQuery$.asObservable();
+    }
+    get currentRefreshQuery() {
+        return this._currentRefreshQuery$.getValue();
+    }
+    constructor(_config) {
+        this._config = _config;
+        this._destroy$ = new Subject();
+        this._currentRefreshQuery$ = new BehaviorSubject(null);
+        this._tokens$ = new BehaviorSubject({
+            token: null,
+            refreshToken: null,
+        });
+        const cookieEnabled = _config.refreshConfig?.cookieEnabled ?? true;
+        const cookieToken = _config.refreshConfig?.cookieName && cookieEnabled ? getCookie(_config.refreshConfig.cookieName) ?? null : null;
+        this._tokens$.next({
+            token: _config.token || null,
+            refreshToken: _config.refreshConfig?.token || cookieToken || null,
+        });
+        if (!this.tokens.token && !this.tokens.refreshToken) {
+            if (!_config.refreshConfig?.cookieName) {
+                console.error('A BearerAuthProvider was created without token or refresh token. You should provide at least a cookieName where the refresh token might be stored.');
+            }
+            return;
         }
-        else {
-            throw error;
+        if (this.tokens.token) {
+            this._prepareForRefresh();
+            if (this.tokens.refreshToken && this._config.refreshConfig?.cookieName) {
+                setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);
+            }
+        }
+        else if (this.tokens.refreshToken) {
+            this._refreshQuery();
         }
     }
+    cleanUp() {
+        this._destroy$.next(true);
+        this._destroy$.unsubscribe();
+        this._currentRefreshQuery$.next(null);
+        if (this._config.refreshConfig?.cookieName) {
+            deleteCookie(this._config.refreshConfig.cookieName, '/');
+        }
+    }
+    enableCookie() {
+        if (!this._config.refreshConfig?.cookieName) {
+            throw new Error('No cookie name was provided');
+        }
+        if (!this.tokens.refreshToken) {
+            throw new Error('No refresh token was provided');
+        }
+        this._config.refreshConfig.cookieEnabled = true;
+        setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);
+    }
+    disableCookie() {
+        if (!this._config.refreshConfig?.cookieName) {
+            throw new Error('No cookie name was provided');
+        }
+        this._config.refreshConfig.cookieEnabled = false;
+        deleteCookie(this._config.refreshConfig.cookieName, '/');
+    }
+    _prepareForRefresh() {
+        if (!this.tokens.token || !this._config.refreshConfig) {
+            return;
+        }
+        const bearer = decryptBearer(this.tokens.token);
+        if (!bearer) {
+            return;
+        }
+        const expiresInPropertyName = this._config.refreshConfig.expiresInPropertyName || 'exp';
+        const expiresIn = bearer[expiresInPropertyName];
+        const fiveMinutes = 5 * 60 * 1000;
+        const refreshBuffer = this._config.refreshConfig.refreshBuffer ?? fiveMinutes;
+        if (expiresIn === undefined) {
+            throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);
+        }
+        const remainingTime = new Date(expiresIn * 1000).getTime() - refreshBuffer - new Date().getTime();
+        const strategy = this._config.refreshConfig.strategy ?? "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */;
+        switch (strategy) {
+            case "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */:
+                timer(remainingTime)
+                    .pipe(takeUntil(this._destroy$))
+                    .subscribe(() => this._refreshQuery());
+                break;
+        }
+    }
+    _refreshQuery() {
+        const currentRefreshToken = this.tokens.refreshToken;
+        if (!currentRefreshToken || !this._config.refreshConfig) {
+            return;
+        }
+        const args = this._config.refreshConfig.requestArgsAdapter?.({
+            token: this.tokens.token,
+            refreshToken: currentRefreshToken,
+        }) ?? {
+            body: { refreshToken: currentRefreshToken },
+        };
+        const query = this._config.refreshConfig.queryCreator.prepare(args).execute({ skipCache: true });
+        this._currentRefreshQuery$.next(query);
+        this._currentRefreshQuery$
+            .pipe(switchQueryState(), tap((state) => {
+            if (isQueryStateSuccess(state)) {
+                if (this._config.refreshConfig?.responseAdapter) {
+                    const tokens = this._config.refreshConfig.responseAdapter(state.response);
+                    this._tokens$.next(tokens);
+                }
+                else {
+                    this._tokens$.next({
+                        token: state.response['token'],
+                        refreshToken: state.response['refreshToken'],
+                    });
+                }
+                const cookieEnabled = this._config.refreshConfig?.cookieEnabled ?? true;
+                if (this._config.refreshConfig?.cookieName && this.tokens.refreshToken && cookieEnabled) {
+                    setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);
+                }
+                this._prepareForRefresh();
+            }
+            else if (isQueryStateFailure(state)) {
+                this._tokens$.next({ token: null, refreshToken: null });
+                if (this._config.refreshConfig?.cookieName) {
+                    deleteCookie(this._config.refreshConfig.cookieName, '/');
+                }
+            }
+        }), takeUntilResponse(), takeUntil(this._destroy$))
+            .subscribe();
+    }
 }
 
 class QueryDirective {
+    get query() {
+        return this._query;
+    }
+    set query(v) {
+        this._query = v;
+        this._subscribeToQuery();
+    }
+    get cache() {
+        return this._cache;
+    }
+    set cache(v) {
+        this._cache = v;
+    }
     constructor(_mainTemplateRef, _viewContainerRef, _errorHandler, _cdr) {
         this._mainTemplateRef = _mainTemplateRef;
         this._viewContainerRef = _viewContainerRef;
@@ -662,22 +899,10 @@ class QueryDirective {
             raw: null,
             loading: false,
             error: null,
+            progress: null,
         };
         this._cache = false;
     }
-    get query() {
-        return this._query;
-    }
-    set query(v) {
-        this._query = v;
-        this._subscribeToQuery();
-    }
-    get cache() {
-        return this._cache;
-    }
-    set cache(v) {
-        this._cache = v;
-    }
     static ngTemplateContextGuard(dir, ctx) {
         return true;
     }
@@ -693,15 +918,18 @@ class QueryDirective {
         if (!this.query) {
             return;
         }
-        const sub = this.query.state$.pipe(tap((state) => this._updateView(state))).subscribe();
+        const query = isQuery(this.query) ? this.query : this.query.query;
+        const sub = query.state$.pipe(tap((state) => this._updateView(state))).subscribe();
         this._subscription = sub;
     }
     _updateView(state) {
         if (isQueryStateLoading(state)) {
             this._viewContext.loading = true;
+            this._viewContext.progress = state.progress ?? null;
         }
         else {
             this._viewContext.loading = false;
+            this._viewContext.progress = null;
         }
         if (isQueryStateSuccess(state)) {
             this._viewContext.query = state.response;
@@ -729,9 +957,9 @@ class QueryDirective {
         }
     }
 }
-QueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: QueryDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.ErrorHandler }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
-QueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.1", type: QueryDirective, isStandalone: true, selector: "[query]", inputs: { query: "query", cache: ["queryCache", "cache"] }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: QueryDirective, decorators: [{
+QueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: QueryDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.ErrorHandler }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+QueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: QueryDirective, isStandalone: true, selector: "[query]", inputs: { query: "query", cache: ["queryCache", "cache"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: QueryDirective, decorators: [{
             type: Directive,
             args: [{
                     // eslint-disable-next-line @angular-eslint/directive-selector
@@ -747,16 +975,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImpor
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 class InfinityQuery {
-    constructor(_config) {
-        this._config = _config;
-        this._currentPage$ = new BehaviorSubject(null);
-        this._currentCalculatedPage$ = new BehaviorSubject(null);
-        this._totalPages$ = new BehaviorSubject(null);
-        this._itemsPerPage$ = new BehaviorSubject(this._config.limitParam?.value ?? 10);
-        this._currentQuery$ = new BehaviorSubject(null);
-        this._data$ = new BehaviorSubject([]);
-        this._subscriptions = [];
-    }
     get currentPage$() {
         return this._currentPage$.asObservable();
     }
@@ -793,6 +1011,16 @@ class InfinityQuery {
     get data() {
         return this._data$.getValue();
     }
+    constructor(_config) {
+        this._config = _config;
+        this._currentPage$ = new BehaviorSubject(null);
+        this._currentCalculatedPage$ = new BehaviorSubject(null);
+        this._totalPages$ = new BehaviorSubject(null);
+        this._itemsPerPage$ = new BehaviorSubject(this._config.limitParam?.value ?? 10);
+        this._currentQuery$ = new BehaviorSubject(null);
+        this._data$ = new BehaviorSubject([]);
+        this._subscriptions = [];
+    }
     nextPage() {
         const newPage = (this._currentPage$.value ?? 0) + 1;
         const calculatedPage = this._config?.pageParam?.valueCalculator?.({
@@ -800,6 +1028,10 @@ class InfinityQuery {
             totalPages: this.totalPages,
             itemsPerPage: this.itemsPerPage,
         }) ?? newPage;
+        if (this.totalPages !== null && calculatedPage > this.totalPages) {
+            console.error('Cannot load more pages, already at the end. Make sure to not render the infinity query trigger using *ngIf canLoadMore');
+            return;
+        }
         const args = this._prepareArgs(this._config, calculatedPage);
         const query = this._config.queryCreator.prepare(args).execute();
         this._handleNewQuery(query);
@@ -925,7 +1157,7 @@ class InfinityQueryDirective {
             itemsPerPage: null,
         };
         this._infinityQueryInstance = null;
-        this._destroy$ = inject(DestroyDirective).destroy$;
+        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
         this._cdr = inject(ChangeDetectorRef);
         this._viewContainerRef = inject(ViewContainerRef);
         this._mainTemplateRef = inject((TemplateRef));
@@ -1040,17 +1272,16 @@ class InfinityQueryDirective {
         this._data$.next([]);
     }
 }
-InfinityQueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: InfinityQueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-InfinityQueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.1", type: InfinityQueryDirective, isStandalone: true, selector: "[infinityQuery]", inputs: { infinityQuery: "infinityQuery" }, providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }], exportAs: ["infinityQuery"], hostDirectives: [{ directive: i1.DestroyDirective }], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: InfinityQueryDirective, decorators: [{
+InfinityQueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: InfinityQueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+InfinityQueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: InfinityQueryDirective, isStandalone: true, selector: "[infinityQuery]", inputs: { infinityQuery: "infinityQuery" }, providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }, DestroyService], exportAs: ["infinityQuery"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: InfinityQueryDirective, decorators: [{
             type: Directive,
             args: [{
                     // eslint-disable-next-line @angular-eslint/directive-selector
                     selector: '[infinityQuery]',
                     exportAs: 'infinityQuery',
                     standalone: true,
-                    providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }],
-                    hostDirectives: [DestroyDirective],
+                    providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }, DestroyService],
                 }]
         }], propDecorators: { infinityQuery: [{
                 type: Input
@@ -1093,9 +1324,9 @@ class InfinityQueryTriggerDirective {
         this._observer.observe(this._elementRef.nativeElement);
     }
 }
-InfinityQueryTriggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: InfinityQueryTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-InfinityQueryTriggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.1", type: InfinityQueryTriggerDirective, isStandalone: true, selector: "[infinityQueryTrigger], infinity-query-trigger", inputs: { scrollContainerSelector: "scrollContainerSelector" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: InfinityQueryTriggerDirective, decorators: [{
+InfinityQueryTriggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: InfinityQueryTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+InfinityQueryTriggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: InfinityQueryTriggerDirective, isStandalone: true, selector: "[infinityQueryTrigger], infinity-query-trigger", inputs: { scrollContainerSelector: "scrollContainerSelector" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: InfinityQueryTriggerDirective, decorators: [{
             type: Directive,
             args: [{
                     // eslint-disable-next-line @angular-eslint/directive-selector
@@ -1187,9 +1418,18 @@ config, args) => {
 };
 
 class QueryClient {
+    get config() {
+        return this._clientConfig;
+    }
+    get authProvider() {
+        return this._authProvider$.getValue() ?? this._clientConfig.parent?._authProvider$.getValue() ?? null;
+    }
+    get authProvider$() {
+        return this._authProvider$.asObservable() ?? this._clientConfig.parent?._authProvider$.asObservable() ?? null;
+    }
     constructor(_clientConfig) {
         this._clientConfig = _clientConfig;
-        this._authProvider = null;
+        this._authProvider$ = new BehaviorSubject(null);
         this.get = (queryConfig) => this.fetch({
             ...queryConfig,
             method: 'GET',
@@ -1246,38 +1486,41 @@ class QueryClient {
             };
         };
         this.setAuthProvider = (authProvider) => {
-            if (this._authProvider) {
+            if (this.authProvider) {
                 throw new Error('The auth provider is already set. Please call clearAuthProvider() first.');
             }
-            this._authProvider = authProvider;
-            authProvider.queryClient = this;
+            this._authProvider$.next(authProvider);
+        };
+        this.setDefaultHeaders = (headers) => {
+            if (!this._clientConfig.request) {
+                this._clientConfig.request = {
+                    headers: headers ?? undefined,
+                };
+            }
+            else {
+                this._clientConfig.request.headers = headers ?? undefined;
+            }
         };
         this.clearAuthProvider = () => {
-            this._authProvider?.cleanUp();
-            this._authProvider = null;
+            this.authProvider?.cleanUp();
+            this._authProvider$.next(null);
         };
         this._store = new QueryStore({
             enableChangeLogging: _clientConfig.logging?.queryStateChanges,
             enableGarbageCollectorLogging: _clientConfig.logging?.queryStateGarbageCollector,
         });
     }
-    get config() {
-        return this._clientConfig;
-    }
-    get authProvider() {
-        return this._authProvider;
-    }
 }
 
 class QueryField {
+    get control() {
+        return this.data.control;
+    }
     constructor(data) {
         this.data = data;
         this.changes$ = this._setupChangesObservable();
         this._currentDebounceTimeout = null;
     }
-    get control() {
-        return this.data.control;
-    }
     setValue(value) {
         if (this._currentDebounceTimeout !== null) {
             clearTimeout(this._currentDebounceTimeout);
@@ -1311,7 +1554,7 @@ class QueryForm {
         this.form = this._setupFormGroup();
     }
     observe(options) {
-        return combineLatest(Object.values(this._fields).map((field) => field.changes$)).pipe(map(() => this.form.getRawValue()), distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), tap((values) => {
+        return combineLatest(Object.values(this._fields).map((field) => field.changes$)).pipe(map(() => this.form.getRawValue()), distinctUntilChanged((a, b) => equal(a, b)), tap((values) => {
             if (options?.syncViaUrlQueryParams !== false) {
                 this._syncViaUrlQueryParams(values);
             }
@@ -1372,7 +1615,7 @@ class QueryForm {
         if (!this._router || !this._activatedRoute) {
             return;
         }
-        const queryParams = structuredClone(this._activatedRoute.snapshot.queryParams);
+        const queryParams = { ...clone(this._activatedRoute.snapshot.queryParams) };
         for (const [key, value] of Object.entries(values)) {
             if (this._isDefaultValue(key, value) || this._fields[key].data.appendToUrl === false) {
                 delete queryParams[key];
@@ -1483,9 +1726,34 @@ const transformToSortQueryParam = (value) => {
     return null;
 };
 
+const deepFreeze = (object) => {
+    // check if object is actually an object or frozen
+    if (!object || typeof object !== 'object' || Object.isFrozen(object)) {
+        return object;
+    }
+    // Retrieve the property names defined on object
+    const propNames = Object.getOwnPropertyNames(object);
+    // Freeze properties before freezing self
+    for (const name of propNames) {
+        const value = object[name];
+        if (value && typeof value === 'object') {
+            deepFreeze(value);
+        }
+    }
+    return Object.freeze(object);
+};
+
+/**
+ * Dummy function for providing types while not breaking inference.
+ * **This function always returns null.**
+ * @see https://github.com/microsoft/TypeScript/issues/26242
+ * @returns null
+ */
+const def = () => null;
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthProvider, CustomHeaderAuthProvider, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, Query, QueryClient, QueryDirective, QueryError, QueryField, QueryForm, QueryStore, buildBody, buildErrorMessage, buildGqlCacheKey, buildQueryArrayString, buildQueryString, buildRequestError, buildRoute, buildTimestampFromSeconds, createInfinityQueryConfig, decryptBearer, deepFreeze, def, extractExpiresInSeconds, filterFailure, filterInvalidParams, filterSuccess, gql, guessContentType, invalidBaseRouteError, invalidBodyError, invalidRouteError, isAbortRequestError, isBasicAuthProvider, isBearerAuthProvider, isCustomHeaderAuthProvider, isFetchResponse, isGqlQueryConfig, isParamValid, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, mergeHeaders, pathParamsMissingInRouteFunctionError, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, request, shouldCacheQuery, skipPaginationPageParamCalculator, takeUntilResponse, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray };
+export { BasicAuthProvider, BearerAuthProvider, CustomHeaderAuthProvider, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, Query, QueryClient, QueryDirective, QueryError, QueryField, QueryForm, QueryStore, buildErrorMessage, buildGqlCacheKey, buildQueryArrayString, buildQueryString, buildRoute, buildTimestampFromSeconds, createInfinityQueryConfig, createQueryCollection, decryptBearer, deepFreeze, def, detectContentTypeHeader, extractExpiresInSeconds, extractQuery, filterFailure, filterInvalidParams, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getResponseUrl, gql, hasHeader, invalidBaseRouteError, invalidBodyError, invalidRouteError, isBasicAuthProvider, isBearerAuthProvider, isCustomHeaderAuthProvider, isFetchResponse, isGqlQueryConfig, isParamValid, isQuery, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, mergeHeaders, parseAllXhrResponseHeaders, pathParamsMissingInRouteFunctionError, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, request, serializeBody, shouldCacheQuery, skipPaginationPageParamCalculator, switchQueryCollectionState, switchQueryState, takeUntilResponse, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray };
 //# sourceMappingURL=ethlete-query.mjs.map