@ethlete/query 5.16.0 → 5.16.2

package/fesm2022/ethlete-query.mjs

@@ -0,0 +1,3289 @@
+import * as i1 from '@ethlete/core';
+import { createDestroy, computedTillTruthy, getCookie, setCookie, deleteCookie, DelayableDirective, nextFrame, RouterStateService, clone, equal, ET_PROPERTY_REMOVED } from '@ethlete/core';
+import { Observable, takeUntil, startWith, pairwise, tap, switchMap, of, BehaviorSubject, Subject, fromEvent, timer, take, filter, takeWhile, map, shareReplay, ReplaySubject, combineLatest, interval, skip, withLatestFrom, debounceTime, merge } from 'rxjs';
+import * as i0 from '@angular/core';
+import { assertInInjectionContext, inject, Injector, computed, signal, isDevMode, untracked, TemplateRef, ViewContainerRef, ErrorHandler, ChangeDetectorRef, Directive, Input, InjectionToken, ElementRef, Pipe, effect, Component, ChangeDetectionStrategy, ViewEncapsulation, NgZone } from '@angular/core';
+import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { AsyncPipe, JsonPipe, NgClass } from '@angular/common';
+import * as i1$1 from '@angular/forms';
+import { FormControl, ReactiveFormsModule, FormGroup } from '@angular/forms';
+import { Router, ActivatedRoute } from '@angular/router';
+
+class CustomHeaderAuthProvider {
+    get header() {
+        return { [this._config.name]: this._config.value };
+    }
+    constructor(_config) {
+        this._config = _config;
+    }
+    cleanUp() {
+        // noop
+    }
+}
+
+class BasicAuthProvider {
+    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 buildErrorMessage = (code, message) => `[@ethlete\\query:${code}] ${message}`;
+class QueryError extends Error {
+    constructor(code, message, data) {
+        super(buildErrorMessage(code, message));
+        this.name = 'QueryError';
+        this.data = data;
+    }
+}
+const invalidBaseRouteError = (data) => new QueryError('001', 'The baseRoute must not end with a slash', data);
+const invalidRouteError = (data) => new QueryError('002', 'The route must start with a slash', data);
+const pathParamsMissingInRouteFunctionError = (data) => new QueryError('003', 'The route is a function but pathParams are missing', data);
+const queryStateAlreadyHasKeyError = (data) => new QueryError('004', 'The query state already contains the provided key', data);
+const queryStateDoesNotContainKeyError = (data) => new QueryError('005', 'The query state does not contain the provided key', data);
+const queryStateCannotTransformError = (data) => new QueryError('006', 'The query state cannot be transformed because it is not loading', data);
+const invalidBodyError = (data) => new QueryError('007', 'The body is not valid or upsupported', data);
+
+const isSymfonyError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const symfonyError = error;
+    return (symfonyError.class !== undefined &&
+        symfonyError.detail !== undefined &&
+        symfonyError.status !== undefined &&
+        symfonyError.title !== undefined &&
+        symfonyError.trace !== undefined &&
+        symfonyError.type !== undefined);
+};
+const isSymfonyPagerfantaOutOfRangeError = (error) => {
+    if (!isSymfonyError(error)) {
+        return false;
+    }
+    return error.class.startsWith('Pagerfanta') && error.class.endsWith('OutOfRangeCurrentPageException');
+};
+const isSymfonyFormViolationListError = (error) => {
+    return typeof error === 'object' && error !== null && 'violations' in error;
+};
+const isSymfonyListError = (error) => {
+    return (!!error &&
+        typeof error === 'object' &&
+        Array.isArray(error) &&
+        !!error.length &&
+        'message' in error[0] &&
+        'propertyPath' in error[0] &&
+        'invalidValue' in error[0]);
+};
+
+const isNaN$1 = (value) => typeof value === 'number' && Number.isNaN(value);
+const isEmptyString = (value) => typeof value === 'string' && value.trim() === '';
+const isRequestError = (error) => error instanceof Object && 'status' in error && 'statusText' in error && 'url' in error;
+const buildRoute = (options) => {
+    if (options.base.endsWith('/')) {
+        throw invalidBaseRouteError(options.base);
+    }
+    let route = null;
+    if (typeof options.route === 'function') {
+        if (!options.pathParams) {
+            throw pathParamsMissingInRouteFunctionError(options.route({}));
+        }
+        route = options.route(options.pathParams);
+    }
+    else {
+        route = options.route ?? null;
+    }
+    if (route && !route.startsWith('/')) {
+        throw invalidRouteError(route);
+    }
+    if (options.queryParams) {
+        const queryString = buildQueryString(options.queryParams, options.queryParamConfig);
+        if (queryString) {
+            route = route ? `${route}?${queryString}` : `/?${queryString}`;
+        }
+    }
+    return `${options.base}${route ?? ''}`;
+};
+const buildQueryString = (params, config) => {
+    const objectNotation = config?.objectNotation ?? 'bracket';
+    const writeArrayIndexes = config?.writeArrayIndexes ?? false;
+    const ignoredValues = config?.ignoredValues ?? [undefined, null, Infinity, -Infinity];
+    const ignoredValuesFns = config?.ignoredValuesFns ?? [isNaN$1, isEmptyString];
+    const queryParams = [];
+    function processValue(key, value) {
+        if (Array.isArray(value)) {
+            let currentFilteredIndex = 0;
+            for (const arrayValue of value) {
+                const nestedKey = writeArrayIndexes ? `${key}[${currentFilteredIndex}]` : `${key}[]`;
+                const didAddValue = processValue(nestedKey, arrayValue);
+                if (didAddValue) {
+                    currentFilteredIndex++;
+                }
+            }
+            return null;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            for (const [objKey, val] of Object.entries(value)) {
+                const nestedKey = objectNotation === 'dot' ? `${key}.${objKey}` : `${key}[${objKey}]`;
+                processValue(nestedKey, val);
+            }
+            return null;
+        }
+        else {
+            if (ignoredValues.includes(value)) {
+                return false;
+            }
+            if (ignoredValuesFns.some((fn) => fn(value))) {
+                return false;
+            }
+            const encodedKey = encodeURIComponent(key);
+            const encodedValue = encodeURIComponent(value);
+            queryParams.push(`${encodedKey}=${encodedValue}`);
+            return true;
+        }
+    }
+    for (const [key, val] of Object.entries(params)) {
+        processValue(key, val);
+    }
+    return queryParams.length ? queryParams.join('&') : null;
+};
+const extractExpiresInSeconds = (headers) => {
+    const cacheControl = headers['cache-control'];
+    const age = headers['age'];
+    const expires = headers['expires'];
+    // In seconds
+    let expiresIn = null;
+    let maxAge = null;
+    if (cacheControl?.includes('no-cache')) {
+        return null;
+    }
+    if (cacheControl?.includes('max-age')) {
+        const m = cacheControl.split('max-age=')[1];
+        if (m) {
+            maxAge = parseInt(m);
+        }
+    }
+    else if (cacheControl?.includes('s-maxage')) {
+        const m = cacheControl.split('s-maxage=')[1];
+        if (m) {
+            maxAge = parseInt(m);
+        }
+    }
+    if (maxAge && age) {
+        const ageSeconds = parseInt(age);
+        expiresIn = maxAge - ageSeconds;
+    }
+    else if (maxAge) {
+        expiresIn = maxAge / 2; // We assume the response is half way to its expiration
+    }
+    else if (expires) {
+        // Used by some apis to tell the response will never expire
+        // In this case we let the response expire after 1 hour
+        if (expires === '-1') {
+            expiresIn = 3600;
+        }
+        else {
+            const expiresDate = new Date(expires);
+            // check if the date is valid
+            if (expiresDate.toString() !== 'Invalid Date') {
+                expiresIn = Math.floor((expiresDate.getTime() - Date.now()) / 1000);
+            }
+        }
+    }
+    return expiresIn;
+};
+const buildTimestampFromSeconds = (seconds) => {
+    if (seconds === null) {
+        return null;
+    }
+    return new Date(Date.now() + seconds * 1000).getTime();
+};
+const serializeBody = (body) => {
+    if (body === null || body === undefined) {
+        return null;
+    }
+    if (body instanceof ArrayBuffer ||
+        body instanceof Blob ||
+        body instanceof FormData ||
+        body instanceof URLSearchParams ||
+        typeof body === 'string') {
+        return body;
+    }
+    if (typeof body === 'object' || typeof body === 'boolean' || Array.isArray(body)) {
+        return JSON.stringify(body);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return body.toString();
+};
+const transformMethod = (config) => {
+    if (config.method === 'GQL_QUERY' || config.method === 'GQL_MUTATE') {
+        if (!config.transferVia) {
+            return 'POST';
+        }
+        return config.transferVia;
+    }
+    return config.method;
+};
+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';
+    }
+    // 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 hasHeader = (headers, header) => {
+    return Object.keys(headers).some((key) => key.toLowerCase() === header.toLowerCase());
+};
+const forEachHeader = (headers, callback) => {
+    Object.entries(headers).forEach(([key, value]) => {
+        callback(key, value);
+    });
+};
+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;
+        }
+    }
+    return parsedHeaders;
+};
+const getResponseUrl = (xhr) => {
+    if ('responseURL' in xhr && xhr.responseURL) {
+        return xhr.responseURL;
+    }
+    if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
+        return xhr.getResponseHeader('X-Request-URL');
+    }
+    return null;
+};
+const shouldRetryRequest = (config) => {
+    const defaultRetryDelay = 1000 + 1000 * config.currentRetryCount;
+    if (config.currentRetryCount > 3) {
+        return { retry: false };
+    }
+    if (!isRequestError(config.error)) {
+        return { retry: false };
+    }
+    const { status, detail } = config.error;
+    // Retry on 5xx errors
+    if (status >= 500) {
+        // Don't retry if a requested page is out of range
+        if (isSymfonyPagerfantaOutOfRangeError(detail)) {
+            return { retry: false };
+        }
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Retry on 408 or 425 errors
+    if (status === 408 /* HttpStatusCode.RequestTimeout */ || status === 425 /* HttpStatusCode.TooEarly */) {
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Retry on 429 errors
+    if (status === 429 /* HttpStatusCode.TooManyRequests */) {
+        const retryAfter = config.headers['retry-after'] ||
+            config.headers['Retry-After'] ||
+            config.headers['x-retry-after'] ||
+            config.headers['X-Retry-After'];
+        if (retryAfter) {
+            const delay = parseInt(retryAfter) * 1000;
+            return { retry: true, delay: Number.isNaN(delay) ? defaultRetryDelay : delay };
+        }
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Code 0 usually means the internet connection is down. We retry in this case.
+    // It could also be a CORS issue but that should not be the case in production.
+    if (status === 0) {
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    return { retry: false };
+};
+
+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] || '';
+    const retryFn = config.retryFn || shouldRetryRequest;
+    let currentRetryCount = 0;
+    let retryTimeout = null;
+    return new Observable((observer) => {
+        const xhr = new XMLHttpRequest();
+        const reqBody = serializeBody(body);
+        const setupXhr = () => {
+            xhr.open(config.method, config.urlWithParams);
+            if (config.withCredentials) {
+                xhr.withCredentials = true;
+            }
+            forEachHeader(headers, (name, value) => xhr.setRequestHeader(name, value));
+            if (!hasHeader(headers, 'Accept')) {
+                xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
+            }
+            if (!hasHeader(headers, 'Content-Type')) {
+                const detectedType = detectContentTypeHeader(body);
+                if (detectedType) {
+                    xhr.setRequestHeader('Content-Type', detectedType);
+                }
+            }
+            xhr.responseType = responseType !== 'json' ? responseType : 'text';
+        };
+        setupXhr();
+        const partialFromXhr = () => {
+            const statusText = xhr.statusText || 'OK';
+            const headers = parseAllXhrResponseHeaders(xhr);
+            const _url = getResponseUrl(xhr) || url;
+            return { headers, status: xhr.status, statusText, url: _url };
+        };
+        const handleRetry = (error) => {
+            const newRetryCount = currentRetryCount + 1;
+            const { headers } = partialFromXhr();
+            const { retry, delay } = retryFn({ currentRetryCount: newRetryCount, headers, error });
+            if (!retry) {
+                observer.next({ type: 'failure', headers, error });
+                observer.complete();
+                return;
+            }
+            const _delay = delay ?? 1000;
+            observer.next({ type: 'delay-retry', headers, retryNumber: newRetryCount, retryDelay: _delay });
+            retryTimeout = window.setTimeout(() => {
+                setupXhr();
+                xhr.send(reqBody);
+                currentRetryCount = newRetryCount;
+                observer.next({ type: 'start', headers, isRetry: true, retryNumber: currentRetryCount, retryDelay: _delay });
+            }, _delay);
+        };
+        const onLoad = async () => {
+            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;
+            }
+            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 };
+                    }
+                }
+            }
+            else if (!ok && body instanceof Blob) {
+                try {
+                    const text = await body.text();
+                    if (body.type === 'application/json') {
+                        body = JSON.parse(text);
+                    }
+                    else {
+                        body = text;
+                    }
+                }
+                catch (error) {
+                    // Ignore the error.
+                }
+            }
+            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 {
+                handleRetry({
+                    url,
+                    detail: body,
+                    status,
+                    statusText,
+                });
+            }
+        };
+        const onError = (error) => {
+            const { url } = partialFromXhr();
+            handleRetry({
+                url,
+                detail: error,
+                status: xhr.status || 0,
+                statusText: xhr.statusText || 'Unknown Error',
+            });
+        };
+        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);
+            }
+        }
+        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 (retryTimeout) {
+                window.clearTimeout(retryTimeout);
+            }
+            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 });
+        };
+    });
+};
+
+const addQueryContainerHandling = (obs, valueFn, config) => {
+    assertInInjectionContext(addQueryContainerHandling);
+    const { abortPrevious, abortOnDestroy, stopPreviousPolling } = config ?? {};
+    const injector = inject(Injector);
+    const destroy$ = createDestroy();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tNode = injector._tNode;
+    const componentId = tNode?.index ?? -1;
+    obs
+        .pipe(takeUntil(destroy$), startWith(null), pairwise(), tap(([prevQuery, currQuery]) => {
+        const cleanQuery = (q) => {
+            if (!q?._hasDependents() && ((abortPrevious === undefined && q?.canBeCached) || abortPrevious)) {
+                q?.abort();
+            }
+            if (!q?._hasDependents() &&
+                ((stopPreviousPolling === undefined && q?.canBeCached) || stopPreviousPolling) &&
+                q?.isPolling) {
+                q?.stopPolling();
+            }
+        };
+        if ((isQuery(prevQuery) || prevQuery === null) && (isQuery(currQuery) || currQuery === null)) {
+            prevQuery?._removeDependent(componentId);
+            currQuery?._addDependent(componentId);
+            cleanQuery(prevQuery);
+        }
+        else if ((Array.isArray(prevQuery) || prevQuery === null) &&
+            (Array.isArray(currQuery) || currQuery === null)) {
+            if (prevQuery) {
+                for (let i = 0; i < prevQuery.length; i++) {
+                    prevQuery[i]?._removeDependent(componentId);
+                }
+            }
+            if (currQuery) {
+                for (let i = 0; i < currQuery.length; i++) {
+                    currQuery[i]?._addDependent(componentId);
+                }
+            }
+            if (prevQuery) {
+                for (let i = 0; i < prevQuery.length; i++) {
+                    cleanQuery(prevQuery[i]);
+                }
+            }
+        }
+        else if ((isQuery(prevQuery) && Array.isArray(currQuery)) ||
+            (Array.isArray(prevQuery) && isQuery(currQuery))) {
+            throw new Error('Cannot mix queries and arrays of queries in the same query container.');
+        }
+    }))
+        .subscribe();
+    destroy$.subscribe(() => {
+        const query = valueFn();
+        const handleQuery = (q) => {
+            q?._removeDependent(componentId);
+            if (!q?._hasDependents() && ((q?.canBeCached && abortOnDestroy === undefined) || abortOnDestroy)) {
+                q?.abort();
+            }
+        };
+        if (isQuery(query)) {
+            handleQuery(query);
+        }
+        else if (Array.isArray(query)) {
+            for (const q of query) {
+                handleQuery(q);
+            }
+        }
+    });
+};
+function toQuerySignal(source, options) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const s = toSignal(source, options);
+    addQueryContainerHandling(source, () => s(), options);
+    return s;
+}
+function queryComputed(computation, options) {
+    const c = computed(computation, options);
+    const obs = toObservable(c, options);
+    addQueryContainerHandling(obs, () => c(), options);
+    return c;
+}
+/**
+ * Creates a signal that will only be reactive until the first query is created.
+ * All subsequent changes inside the computation will be ignored.
+ */
+function queryComputedTillTruthy(computation, options) {
+    const c = computedTillTruthy(computed(computation, options));
+    const obs = toObservable(c, options);
+    addQueryContainerHandling(obs, () => c(), options);
+    return c;
+}
+function queryArrayComputed(computation, options) {
+    const c = computed(computation, options);
+    const obs = toObservable(c, options);
+    addQueryContainerHandling(obs, () => c(), options);
+    return c;
+}
+function toQuerySubject(source, options) {
+    const obs = toObservable(source, options);
+    addQueryContainerHandling(obs, () => source(), options);
+    return obs;
+}
+function queryStateSignal(source, options) {
+    const { cacheResponse } = options ?? {};
+    return toSignal(toObservable(source).pipe(switchMap((q) => extractQuery(q)?.state$ ?? of(null)), switchMap((state) => {
+        if (cacheResponse) {
+            return of(state).pipe(filterQueryStates(["SUCCESS" /* QueryStateType.Success */, "FAILURE" /* QueryStateType.Failure */, "CANCELLED" /* QueryStateType.Cancelled */]));
+        }
+        return of(state);
+    })), {
+        initialValue: null,
+    });
+}
+function queryStateResponseSignal(source, options) {
+    const s = queryStateSignal(source, options);
+    return computed(() => {
+        const state = s();
+        return isQueryStateSuccess(state) ? state.response : null;
+    });
+}
+function queryStateErrorSignal(source) {
+    const s = queryStateSignal(source);
+    return computed(() => {
+        const state = s();
+        return isQueryStateFailure(state) ? state.error : null;
+    });
+}
+function queryStateLoadingSignal(source) {
+    const s = queryStateSignal(source);
+    return computed(() => {
+        const state = s();
+        return isQueryStateLoading(state) ? state : 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;
+
+class QueryCreator {
+    constructor(_queryConfig, _client, _store) {
+        this._queryConfig = _queryConfig;
+        this._client = _client;
+        this._store = _store;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.prepare = (args) => {
+            const route = buildRoute({
+                base: this._client.config.baseRoute,
+                route: this._queryConfig.route,
+                pathParams: args?.pathParams,
+                queryParams: computeQueryQueryParams({ config: this._queryConfig, client: this._client, args }),
+                queryParamConfig: this._client.config.request?.queryParams,
+            });
+            const cacheKey = (args?.config?.queryStoreCacheKey ?? '') + buildQueryCacheKey(route, args);
+            if (shouldCacheQuery(this._queryConfig.method) && !args?.config?.skipQueryStore) {
+                const existingQuery = this._store.get(cacheKey);
+                if (existingQuery) {
+                    return existingQuery;
+                }
+            }
+            const query = new Query(this._client, this._queryConfig, route, args ?? {}, cacheKey);
+            if (shouldCacheQuery(this._queryConfig.method) && !args?.config?.skipQueryStore) {
+                this._store.add(cacheKey, query);
+            }
+            this._store._dispatchQueryCreated(query);
+            return query;
+        };
+        this.createSubject = (initialValue, config) => {
+            assertInInjectionContext(this.createSubject);
+            const subject = new BehaviorSubject(initialValue ?? null);
+            addQueryContainerHandling(subject, () => subject.getValue(), config);
+            return subject;
+        };
+        this.createSignal = (initialValue, config) => {
+            assertInInjectionContext(this.createSignal);
+            const _signal = signal(initialValue ?? null);
+            addQueryContainerHandling(toObservable(_signal), () => _signal(), config);
+            return _signal;
+        };
+        /**
+         * @deprecated Use `myQuery.createSubject()` or `myQuery.createSignal()` instead. Will be removed in v6.
+         */
+        this.behaviorSubject = (initialValue) => new BehaviorSubject(initialValue ?? null);
+    }
+}
+
+class QueryStore {
+    constructor(_config) {
+        this._config = _config;
+        /**
+         * @internal
+         */
+        this._store = new Map();
+        this._garbageCollector = null;
+        this._isInLowResourceMode = false;
+        this._lastBlurTimestamp = Date.now();
+        this._storeChange$ = new Subject();
+        this._queryCreated$ = new Subject();
+        this.storeChange$ = this._storeChange$.asObservable();
+        this.queryCreated$ = this._queryCreated$.asObservable();
+        this._initSmartQueryHandling();
+    }
+    add(id, query) {
+        this._store.set(id, query);
+        this._initGarbageCollector();
+        this._logState(id, query, 'SET');
+        this._storeChange$.next(id);
+    }
+    get(id) {
+        return this._store.get(id) ?? null;
+    }
+    remove(id) {
+        this._store.delete(id);
+        this._logState(id, null, 'REMOVE');
+        this._storeChange$.next(id);
+    }
+    forEach(callback) {
+        for (const [key, query] of this._store) {
+            callback(query, key);
+        }
+    }
+    refreshQueriesInUse(config) {
+        const { ignoreCacheValidity, purgeUnused } = config ?? {};
+        for (const [key, query] of this._store) {
+            if (query.isInUse &&
+                (query.isExpired || ignoreCacheValidity) &&
+                query.autoRefreshOnConfig.queryClientDefaultHeadersChange) {
+                query.execute({ skipCache: true, _triggeredVia: 'auto' });
+            }
+            else if (purgeUnused && !query.isInUse) {
+                this.remove(key);
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    _dispatchQueryCreated(query) {
+        this._queryCreated$.next(query);
+    }
+    _initSmartQueryHandling() {
+        const windowBlur$ = fromEvent(window, 'blur');
+        const windowFocus$ = fromEvent(window, 'focus');
+        windowBlur$.subscribe(() => {
+            timer(5000)
+                .pipe(takeUntil(windowFocus$), take(1))
+                .subscribe(() => {
+                this._lastBlurTimestamp = Date.now();
+                this._isInLowResourceMode = true;
+                this._stopGarbageCollector();
+                if (this._config?.enableSmartPolling) {
+                    this.forEach((query) => {
+                        if (!query.isPolling || !query._enableSmartPolling) {
+                            return;
+                        }
+                        query.pausePolling();
+                    });
+                }
+            });
+        });
+        windowFocus$.subscribe(() => {
+            if (!this._isInLowResourceMode) {
+                return;
+            }
+            this._isInLowResourceMode = false;
+            if (this._config?.enableSmartPolling || this._config?.autoRefreshQueriesOnWindowFocus) {
+                this.forEach((query) => {
+                    if (this._config?.enableSmartPolling && query._isPollingPaused) {
+                        query.resumePolling();
+                    }
+                    if (Date.now() - this._lastBlurTimestamp > 15000) {
+                        if (this._config?.autoRefreshQueriesOnWindowFocus &&
+                            query.isExpired &&
+                            query.isInUse &&
+                            query.autoRefreshOnConfig.windowFocus) {
+                            query.execute({ skipCache: true, _triggeredVia: 'auto' });
+                        }
+                    }
+                });
+            }
+            this._initGarbageCollector();
+        });
+    }
+    _logState(key, item, operation) {
+        if (!this._config?.enableChangeLogging)
+            return;
+        const stateAsJson = {};
+        this._store.forEach((value, key) => {
+            stateAsJson[key] = value;
+        });
+        console.log(`%c[${operation}] ${key}`, 'font-weight: bold');
+        console.log({ operation, key, item });
+        console.log(stateAsJson);
+    }
+    _initGarbageCollector() {
+        if (this._garbageCollector !== null) {
+            return;
+        }
+        this._logGarbageCollector('Start');
+        this._garbageCollector = window.setInterval(() => {
+            this._runGarbageCollector();
+        }, 15000);
+    }
+    _stopGarbageCollector() {
+        if (this._garbageCollector !== null) {
+            window.clearInterval(this._garbageCollector);
+            this._garbageCollector = null;
+            this._logGarbageCollector('Stop');
+        }
+    }
+    _runGarbageCollector() {
+        this._logGarbageCollector('Collecting...');
+        this._store.forEach((item, key) => {
+            if (item.isExpired && !item.isInUse) {
+                this.remove(key);
+            }
+        });
+        this._logGarbageCollector('Collection done');
+        if (!this._store.size) {
+            this._stopGarbageCollector();
+        }
+    }
+    _logGarbageCollector(action) {
+        if (!this._config?.enableGarbageCollectorLogging)
+            return;
+        console.log(`%cGC: ${action}`, 'color: yellow; font-weight: bold');
+    }
+}
+
+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$ = new BehaviorSubject(null);
+        this.get = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'GET',
+        });
+        this.post = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'POST',
+        });
+        this.put = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'PUT',
+        });
+        this.patch = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'PATCH',
+        });
+        this.delete = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'DELETE',
+        });
+        this.gqlQuery = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'GQL_QUERY',
+        });
+        this.gqlMutate = (queryConfig) => this.fetch({
+            ...queryConfig,
+            method: 'GQL_MUTATE',
+        });
+        this.fetch = (queryConfig) => new QueryCreator(queryConfig, this, this._store);
+        this.setAuthProvider = (authProvider) => {
+            if (this.authProvider) {
+                this.authProvider?.cleanUp();
+            }
+            this._authProvider$.next(authProvider);
+        };
+        this.setDefaultHeaders = (config) => {
+            if (!this._clientConfig.request) {
+                this._clientConfig.request = {
+                    headers: config.headers ?? undefined,
+                };
+            }
+            else {
+                this._clientConfig.request.headers = config.headers ?? undefined;
+            }
+            if (config.refreshQueriesInUse) {
+                this._store.refreshQueriesInUse({ purgeUnused: true, ignoreCacheValidity: true });
+            }
+        };
+        this.clearAuthProvider = () => {
+            this.authProvider?.cleanUp();
+            this._authProvider$.next(null);
+        };
+        this._updateBaseRoute = (route) => {
+            this._clientConfig.baseRoute = route;
+        };
+        this._store = new QueryStore({
+            enableChangeLogging: _clientConfig.logging?.queryStateChanges,
+            enableGarbageCollectorLogging: _clientConfig.logging?.queryStateGarbageCollector,
+            autoRefreshQueriesOnWindowFocus: _clientConfig.request?.autoRefreshQueriesOnWindowFocus ?? true,
+            enableSmartPolling: _clientConfig.request?.enableSmartPolling ?? true,
+        });
+    }
+}
+
+const shouldCacheQuery = (method) => {
+    return method === 'GET' || method === 'OPTIONS' || method === 'HEAD' || method === 'GQL_QUERY';
+};
+const buildQueryCacheKey = (route, args) => {
+    const variables = JSON.stringify(args?.variables || {})
+        // replace all curly braces with empty string
+        .replace(/{|}/g, '')
+        // replace new lines and whitespaces with empty string
+        .replace(/\s/g, '');
+    const seed = `${route}...${variables}`;
+    let hash = 0;
+    for (const char of seed) {
+        hash = (Math.imul(31, hash) + char.charCodeAt(0)) << 0;
+    }
+    // Force positive number hash.
+    // 2147483647 = equivalent of Integer.MAX_VALUE.
+    hash += 2147483647 + 1;
+    return hash.toString();
+};
+
+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;
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function filterSuccess() {
+    return function (source) {
+        return source.pipe(filter((value) => isQueryStateSuccess(value)));
+    };
+}
+function ignoreAutoRefresh() {
+    return function (source) {
+        return source.pipe(filter((value) => !isAutoRefresh(value)));
+    };
+}
+function filterFailure() {
+    return function (source) {
+        return source.pipe(filter((value) => isQueryStateFailure(value)));
+    };
+}
+function filterQueryStates(allowedStates) {
+    return function (source) {
+        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) || isQueryStatePrepared(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 resetPageOnError = (config) => (source) => {
+    const { queryForm, pageControlKey = 'page' } = config;
+    if (isDevMode() && !queryForm.form.controls[pageControlKey]) {
+        console.warn(`resetPageOnError: queryForm.form.controls["${pageControlKey}"] is undefined`);
+    }
+    return source.pipe(switchMap((q) => {
+        if (!q) {
+            return of(q);
+        }
+        return q.state$.pipe(tap((state) => {
+            if (!isQueryStateFailure(state)) {
+                return;
+            }
+            switch (state.error.status) {
+                // The page is invalid (in prod mode, code is 416)
+                case 416 /* HttpStatusCode.RangeNotSatisfiable */:
+                    queryForm.form.controls[pageControlKey]?.patchValue(1);
+                    break;
+                // The page might be invalid (in dev mode, code is 500)
+                case 500 /* HttpStatusCode.InternalServerError */:
+                    if (isSymfonyPagerfantaOutOfRangeError(state.error.detail)) {
+                        queryForm.form.controls[pageControlKey].patchValue(1);
+                    }
+                    break;
+            }
+        }), takeUntilResponse());
+    }));
+};
+const isQueryStateLoading = (state) => state?.type === "LOADING" /* QueryStateType.Loading */;
+const isQueryStateSuccess = (state) => state?.type === "SUCCESS" /* QueryStateType.Success */;
+const isQueryStateFailure = (state) => state?.type === "FAILURE" /* QueryStateType.Failure */;
+const isQueryStateCancelled = (state) => state?.type === "CANCELLED" /* QueryStateType.Cancelled */;
+const isQueryStatePrepared = (state) => state?.type === "PREPARED" /* QueryStateType.Prepared */;
+const isAutoRefresh = (state) => state?.meta.triggeredVia === 'auto';
+const mergeHeaders = (...headers) => {
+    return headers.reduce((acc, headers) => {
+        if (!headers) {
+            return acc;
+        }
+        return {
+            ...acc,
+            ...headers,
+        };
+    }, {});
+};
+const isGqlQueryConfig = (config) => {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        return false;
+    }
+    if (!('query' in config)) {
+        return false;
+    }
+    return true;
+};
+const isQuery = (query) => {
+    if (!query || typeof query !== 'object' || Array.isArray(query)) {
+        return false;
+    }
+    if (!('state$' in query)) {
+        return false;
+    }
+    return true;
+};
+const isQueryCollection = (query) => {
+    if (!query || typeof query !== 'object' || Array.isArray(query)) {
+        return false;
+    }
+    if (!('query' in query)) {
+        return false;
+    }
+    return true;
+};
+/**
+ * @deprecated Use `createQueryCollectionSubject` instead. Will be removed in v6.
+ */
+const createQueryCollection = (
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+queryMap) => new BehaviorSubject(null);
+const createQueryCollectionSubject = (
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+queryMap, config) => {
+    assertInInjectionContext(createQueryCollectionSubject);
+    const subject = new BehaviorSubject(null);
+    addQueryContainerHandling(subject.pipe(map((s) => s?.query ?? null)), () => subject.getValue()?.query ?? null, config);
+    return subject;
+};
+const createQueryCollectionSignal = (
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+queryMap, config) => {
+    assertInInjectionContext(createQueryCollectionSignal);
+    const _signal = signal(null);
+    addQueryContainerHandling(toObservable(_signal).pipe(map((s) => s?.query ?? null)), () => _signal()?.query ?? null, config);
+    return _signal;
+};
+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;
+};
+const castQueryCreatorTypes = (config) => {
+    if (config.args?.pathParams) {
+        console.error(config);
+        throw new Error('Path params cannot be overridden in castQueryCreatorTypes. Create a new query creator instead.');
+    }
+    return config.creator;
+};
+const computeQueryMethod = (config) => {
+    let method;
+    if (isGqlQueryConfig(config.config)) {
+        const transferVia = config.config.transferVia ?? config.client.config.request?.gql?.transferVia;
+        method = transformMethod({ method: config.config.method, transferVia });
+    }
+    else {
+        method = transformMethod({ method: config.config.method });
+    }
+    return method;
+};
+const computeQueryBody = (config) => {
+    let body;
+    if (config.method === 'GET' ||
+        config.method === 'HEAD' ||
+        config.method === 'OPTIONS' ||
+        (isGqlQueryConfig(config.config) &&
+            (config.config.transferVia === 'GET' ||
+                (config.client.config.request?.gql?.transferVia === 'GET' && !config.config.transferVia)))) {
+        return undefined;
+    }
+    if (isGqlQueryConfig(config.config)) {
+        const queryTemplate = config.config.query;
+        const query = transformGql(queryTemplate);
+        body = query(config.args?.variables);
+    }
+    else {
+        body = config.args?.body;
+    }
+    return body;
+};
+const computeQueryAuthHeader = (config) => {
+    let authHeader = null;
+    if (config.config.secure) {
+        const header = config.client.authProvider?.header;
+        if (header) {
+            authHeader = header;
+        }
+    }
+    else if (config.client.authProvider?.header) {
+        if (config.config.secure === undefined || config.config.secure) {
+            authHeader = config.client.authProvider.header;
+        }
+    }
+    return authHeader;
+};
+const computeQueryHeaders = (config) => {
+    const authHeader = computeQueryAuthHeader(config);
+    const mergedHeaders = mergeHeaders(getDefaultHeaders(config.client.config.request?.headers, config.config.method), authHeader, config.args?.headers) || undefined;
+    return mergedHeaders;
+};
+const computeQueryQueryParams = (config) => {
+    if (isGqlQueryConfig(config.config) &&
+        (config.config.transferVia === 'GET' ||
+            (config.client.config.request?.gql?.transferVia === 'GET' && !config.config.transferVia))) {
+        const queryTemplate = config.config.query;
+        const query = transformGql(queryTemplate);
+        let params = query(config.args?.variables);
+        if (config.args?.queryParams) {
+            params = { ...params, ...config.args?.queryParams };
+        }
+        return params;
+    }
+    return config.args?.queryParams;
+};
+const paginatedEntityValueUpdater = (findFn) => ({ response, rawResponse, entity }) => {
+    const indexOfEntityRaw = rawResponse.items.findIndex((item) => findFn(item, entity));
+    const indexOfEntity = response.items.findIndex((item) => findFn(item, entity));
+    if (indexOfEntity === -1 || indexOfEntityRaw === -1) {
+        return null;
+    }
+    const newRawResponse = {
+        ...rawResponse,
+        items: [
+            ...rawResponse.items.slice(0, indexOfEntityRaw),
+            entity,
+            ...rawResponse.items.slice(indexOfEntityRaw + 1),
+        ],
+    };
+    const newResponse = {
+        ...response,
+        items: [...response.items.slice(0, indexOfEntity), entity, ...response.items.slice(indexOfEntity + 1)],
+    };
+    return {
+        response: newResponse,
+        rawResponse: newRawResponse,
+    };
+};
+
+let _nextQueryId = 0;
+class Query {
+    get _nextId() {
+        return ++this._currentLocalId;
+    }
+    get state$() {
+        return this._state$.pipe(tap((s) => {
+            if (!this._client.config.logging?.preparedQuerySubscriptions)
+                return;
+            if (isQueryStatePrepared(s)) {
+                console.warn(`Query ${this._routeWithParams} was subscribed to in the prepared state. Did you forget to call .execute()?`);
+            }
+        }), switchMap((s) => this._transformState(s)), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    /**
+     * The current state of the query.
+     *
+     * **Warning!** This differs from the `state$` observable in that it does not use the query store. Thus, the response data might be outdated.
+     * Use `state$` (or `firstValueFrom(state$)`) the most up-to-date data.
+     */
+    get rawState() {
+        return this._state$.value;
+    }
+    get isExpired() {
+        if (isQueryStateLoading(this.rawState)) {
+            return false;
+        }
+        if (isQueryStatePrepared(this.rawState) ||
+            isQueryStateCancelled(this.rawState) ||
+            isQueryStateFailure(this.rawState)) {
+            return true;
+        }
+        const ts = this.rawState.meta.expiresAt;
+        if (!ts) {
+            return true;
+        }
+        return ts < Date.now();
+    }
+    get isInUse() {
+        return this._state$.observed || Object.keys(this._dependents).length > 0;
+    }
+    /**
+     * @internal
+     */
+    get _subscriberCount() {
+        return this._state$.observers.length;
+    }
+    get isPolling() {
+        return !!this._pollingSubscription;
+    }
+    get autoRefreshOnConfig() {
+        const base = this._queryConfig.autoRefreshOn ?? {};
+        const transformed = {
+            queryClientDefaultHeadersChange: base.queryClientDefaultHeadersChange ?? true,
+            windowFocus: base.windowFocus ?? true,
+        };
+        return transformed;
+    }
+    /**
+     * @internal
+     */
+    get _enableSmartPolling() {
+        return this._queryConfig.enableSmartPolling ?? true;
+    }
+    get store() {
+        return this._queryConfig.entity?.store ?? null;
+    }
+    get canBeCached() {
+        return shouldCacheQuery(this._queryConfig.method);
+    }
+    get _isInMockMode() {
+        return !!this._arguments?.mock;
+    }
+    constructor(_client, 
+    /**
+     * @internal
+     */
+    _queryConfig, 
+    /**
+     * @internal
+     */
+    _routeWithParams, 
+    /**
+     * @internal
+     */
+    _arguments, 
+    /**
+     * @internal
+     */
+    _queryStoreKey) {
+        this._client = _client;
+        this._queryConfig = _queryConfig;
+        this._routeWithParams = _routeWithParams;
+        this._arguments = _arguments;
+        this._queryStoreKey = _queryStoreKey;
+        this._id = _nextQueryId++;
+        this._currentLocalId = 0;
+        this._pollingSubscription = null;
+        this._onAbort$ = new Subject();
+        this._currentPollConfig = null;
+        /**
+         * @internal
+         * Used to track which components depend on this query.
+         * The key is the component's _tNode index.
+         * The value is the number of times the component has subscribed to this query.
+         * The value might increase since we cant distinguish between a component and a host directive applied to it.
+         */
+        this._dependents = {};
+        /**
+         * @internal
+         */
+        this._dependentsChanged$ = new ReplaySubject();
+        /**
+         * @internal
+         */
+        this._isPollingPaused = false;
+        this._state$ = new BehaviorSubject({
+            type: "PREPARED" /* QueryStateType.Prepared */,
+            meta: { id: this._currentLocalId, triggeredVia: 'program' },
+        });
+    }
+    execute(options = {}) {
+        const { skipCache = false, _triggeredVia: triggeredVia = 'program', cancelPrevious = false } = options;
+        const { authProvider } = this._client;
+        const queryConfig = this._queryConfig;
+        if (!this.isExpired && !skipCache && isQueryStateSuccess(this.rawState)) {
+            return this;
+        }
+        if (queryConfig.secure && !authProvider && !this._isInMockMode) {
+            throw new Error('Cannot execute secure query without auth provider');
+        }
+        const id = this._nextId;
+        const meta = { id, triggeredVia };
+        if (isQueryStateLoading(this.rawState)) {
+            if (cancelPrevious) {
+                this.abort();
+            }
+            else {
+                return this;
+            }
+        }
+        this._updateState({ type: "LOADING" /* QueryStateType.Loading */, meta });
+        if (this._isInMockMode) {
+            this._mockRequest({}, meta, options);
+        }
+        else {
+            let goSignal = of(true);
+            if (authProvider &&
+                isBearerAuthProvider(authProvider) &&
+                queryConfig.secure &&
+                !isQueryStateSuccess(authProvider.currentRefreshQuery?.rawState)) {
+                // On page load the query might be executed before the auth provider has been initialized.
+                // In this case we need to wait for the auth provider to be ready before we can execute the query.
+                goSignal = combineLatest([
+                    // The tokens might get set without a refresh query being created (e.g.) directly after login.
+                    authProvider.currentRefreshQuery$.pipe(switchQueryState(), takeUntilResponse()),
+                    authProvider.tokens$.pipe(take(1)),
+                ]).pipe(takeUntil(this._onAbort$), filter(([state, tokens]) => {
+                    if (state) {
+                        return !isQueryStateLoading(state);
+                    }
+                    return !!tokens;
+                }), tap(([state]) => {
+                    if (isQueryStateFailure(state)) {
+                        this._updateEntityState({ type: 'failure', error: state.error, headers: {} }, meta, options);
+                    }
+                }), map(() => true), take(1));
+            }
+            goSignal
+                .pipe(switchMap(() => {
+                const method = computeQueryMethod({ config: queryConfig, client: this._client });
+                const body = computeQueryBody({ config: queryConfig, client: this._client, args: this._arguments, method });
+                const headers = computeQueryHeaders({ client: this._client, config: queryConfig, args: this._arguments });
+                return request({
+                    urlWithParams: this._routeWithParams,
+                    method,
+                    body,
+                    headers,
+                    reportProgress: queryConfig.reportProgress,
+                    responseType: queryConfig.responseType,
+                    withCredentials: queryConfig.withCredentials,
+                    cacheAdapter: this._client.config.request?.cacheAdapter,
+                    retryFn: this._client.config.request?.retryFn,
+                }).pipe(tap((state) => this._updateEntityState(state, meta, options)), takeUntil(this._onAbort$));
+            }))
+                .subscribe();
+        }
+        return this;
+    }
+    abort() {
+        if (!isQueryStateLoading(this.rawState)) {
+            return this;
+        }
+        this._onAbort$.next();
+        this._updateState({
+            type: "CANCELLED" /* QueryStateType.Cancelled */,
+            meta: { id: this.rawState.meta.id, triggeredVia: this.rawState.meta.triggeredVia },
+        });
+        return this;
+    }
+    poll(config) {
+        if (this._pollingSubscription) {
+            return this;
+        }
+        this._currentPollConfig = config;
+        const interval$ = interval(config.interval);
+        const poll$ = interval$.pipe(skip(config.triggerImmediately ? 0 : 1), takeUntil(config.takeUntil), takeWhile(() => !this._isPollingPaused), filter(() => !isQueryStateLoading(this._state$.value)));
+        this._pollingSubscription = poll$.subscribe({
+            next: () => this.execute({ skipCache: true, _triggeredVia: 'poll' }),
+            complete: () => this.stopPolling(),
+        });
+        return this;
+    }
+    stopPolling() {
+        this._pollingSubscription?.unsubscribe();
+        this._pollingSubscription = null;
+        this._currentPollConfig = null;
+        return this;
+    }
+    pausePolling() {
+        this._pollingSubscription?.unsubscribe();
+        this._pollingSubscription = null;
+        this._isPollingPaused = true;
+        return this;
+    }
+    resumePolling() {
+        if (!this._isPollingPaused || !this._currentPollConfig) {
+            return this;
+        }
+        this._isPollingPaused = false;
+        return this.poll({ ...this._currentPollConfig, triggerImmediately: true });
+    }
+    onSuccess(callback) {
+        this.state$.pipe(takeUntilResponse(), filterSuccess()).subscribe((state) => callback(state.response));
+        return this;
+    }
+    onFailure(callback) {
+        this.state$.pipe(takeUntilResponse(), filterFailure()).subscribe((state) => callback(state.error));
+        return this;
+    }
+    _getBearerAuthProvider() {
+        const authProvider = this._client.authProvider;
+        if (authProvider && isBearerAuthProvider(authProvider)) {
+            return authProvider;
+        }
+        return null;
+    }
+    _updateEntityState(requestEvent, meta, options) {
+        switch (requestEvent.type) {
+            case 'start':
+            case 'delay-retry': {
+                const { type, retryDelay, retryNumber } = requestEvent;
+                const newMeta = { ...meta, isWaitingForRetry: type === 'delay-retry', retryDelay, retryNumber };
+                this._updateState({
+                    type: "LOADING" /* QueryStateType.Loading */,
+                    meta: newMeta,
+                });
+                break;
+            }
+            case 'upload-progress':
+            case 'download-progress': {
+                this._updateState({
+                    type: "LOADING" /* QueryStateType.Loading */,
+                    progress: requestEvent.progress,
+                    partialText: 'partialText' in requestEvent ? requestEvent.partialText : undefined,
+                    meta,
+                });
+                break;
+            }
+            case 'success': {
+                const { response, expiresInTimestamp } = requestEvent;
+                const isGql = isGqlQueryConfig(this._queryConfig);
+                const responseData = isGql && typeof response === 'object' && !!response && 'data' in response
+                    ? response['data']
+                    : response;
+                if (this._queryConfig.entity && this._queryConfig.entity.set) {
+                    const id = this._queryConfig.entity?.id({ args: this._arguments, response: responseData });
+                    this._queryConfig.entity?.set({
+                        args: this._arguments,
+                        response: responseData,
+                        id,
+                        store: this._queryConfig.entity.store,
+                    });
+                }
+                this._updateState({
+                    type: "SUCCESS" /* QueryStateType.Success */,
+                    response: responseData,
+                    meta: { ...meta, expiresAt: expiresInTimestamp },
+                });
+                break;
+            }
+            case 'failure': {
+                const { error } = requestEvent;
+                const failure = () => this._updateState({ type: "FAILURE" /* QueryStateType.Failure */, error, meta });
+                const bearerAuthProvider = this._getBearerAuthProvider();
+                if (!bearerAuthProvider ||
+                    options?._isUnauthorizedRetry ||
+                    error.status !== 401 /* HttpStatusCode.Unauthorized */ ||
+                    !bearerAuthProvider.shouldRefreshOnUnauthorizedResponse) {
+                    return failure();
+                }
+                const query = bearerAuthProvider._refreshQuery();
+                if (!query)
+                    return failure();
+                query.state$
+                    .pipe(takeUntilResponse(), takeUntil(this._onAbort$), tap((state) => isQueryStateSuccess(state) ? this.execute({ ...options, _isUnauthorizedRetry: true }) : failure()))
+                    .subscribe();
+                break;
+            }
+            case 'cancel': {
+                this._updateState({
+                    type: "CANCELLED" /* QueryStateType.Cancelled */,
+                    meta,
+                });
+                break;
+            }
+        }
+    }
+    _transformState(s) {
+        if (!isQueryStateSuccess(s) || !this._queryConfig.entity?.get) {
+            return of(s);
+        }
+        const id = this._queryConfig.entity.id({ args: this._arguments, response: s.response });
+        return this._queryConfig.entity
+            .get({ args: this._arguments, id, response: s.response, store: this._queryConfig.entity.store })
+            .pipe(map((v) => ({ ...s, response: v })));
+    }
+    _updateState(s) {
+        // We need to use untracked here to avoid Angular's "allowSignalWrites is false" error when executing queries inside Angular's computed/effect signal functions.
+        untracked(() => this._state$.next(s));
+    }
+    _mockRequest(headers, meta, options) {
+        if (!this._arguments?.mock)
+            return;
+        const { delay = 200, error, response, retryIntoResponse = false, progress } = this._arguments.mock;
+        const progressFileSize = progress?.fileSize ?? 1000000;
+        const progressEventType = progress?.eventType ?? 'upload';
+        const progressEventCount = progress?.eventCount ?? 5;
+        const progressOmitTotal = progress?.omitTotal ?? false;
+        const omitPartialText = progress?.omitPartialText ?? false;
+        const finalResolveMock = () => {
+            if (error) {
+                this._updateEntityState({ error, headers: headers ?? {}, type: 'failure' }, meta, options);
+                return;
+            }
+            this._updateEntityState({ response: response, headers: headers ?? {}, type: 'success' }, meta, options);
+        };
+        if (progress) {
+            interval(delay)
+                .pipe(tap((a) => {
+                if (a === progressEventCount + 1) {
+                    finalResolveMock();
+                }
+                else {
+                    const current = Math.min(progressFileSize * a, progressFileSize * progressEventCount);
+                    const percentage = (current / (progressFileSize * progressEventCount)) * 100;
+                    this._updateEntityState({
+                        type: progressEventType === 'upload' ? 'upload-progress' : 'download-progress',
+                        headers: headers ?? {},
+                        progress: { current, ...(progressOmitTotal ? {} : { percentage, total: progressFileSize }) },
+                        partialText: omitPartialText ? undefined : `Partial text ${a}`,
+                    }, meta, options);
+                }
+            }), takeUntil(this._onAbort$), takeWhile((a) => a < progressEventCount + 1, true))
+                .subscribe();
+        }
+        else if (retryIntoResponse) {
+            interval(delay)
+                .pipe(tap((a) => {
+                if (a === 3) {
+                    finalResolveMock();
+                }
+                else {
+                    const aModified = a + 1;
+                    this._updateEntityState({
+                        type: 'delay-retry',
+                        headers: headers ?? {},
+                        retryDelay: 1000 + 1000 * aModified,
+                        retryNumber: aModified,
+                    }, meta, options);
+                }
+            }), takeUntil(this._onAbort$), takeWhile((a) => a < 3, true))
+                .subscribe();
+        }
+        else {
+            timer(delay)
+                .pipe(tap(() => finalResolveMock()), takeUntil(this._onAbort$))
+                .subscribe();
+        }
+    }
+    /**
+     * @internal
+     */
+    _addDependent(tNodeIndex) {
+        if (!this._dependents[tNodeIndex]) {
+            this._dependents[tNodeIndex] = 0;
+        }
+        this._dependents[tNodeIndex]++;
+        this._dependentsChanged$.next(this._dependents);
+    }
+    /**
+     * @internal
+     */
+    _removeDependent(tNodeIndex) {
+        const count = this._dependents[tNodeIndex];
+        if (count === undefined) {
+            return;
+        }
+        if (this._dependents[tNodeIndex] !== undefined) {
+            this._dependents[tNodeIndex]--;
+        }
+        if (count <= 1) {
+            delete this._dependents[tNodeIndex];
+        }
+        this._dependentsChanged$.next(this._dependents);
+    }
+    /**
+     * @internal
+     */
+    _hasDependents() {
+        return Object.keys(this._dependents).length > 0;
+    }
+}
+
+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];
+        if (!base64Url) {
+            return null;
+        }
+        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();
+    }
+    get shouldRefreshOnUnauthorizedResponse() {
+        return (!!this._config.refreshConfig &&
+            (this._config.refreshConfig.refreshOnUnauthorizedResponse === undefined ||
+                this._config.refreshConfig.refreshOnUnauthorizedResponse));
+    }
+    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;
+        }
+        if (this.tokens.token) {
+            this._prepareForRefresh();
+            if (this.tokens.refreshToken && this._config.refreshConfig?.cookieName && cookieEnabled) {
+                this._setCookie();
+            }
+        }
+        else if (this.tokens.refreshToken) {
+            this._refreshQuery();
+        }
+    }
+    cleanUp() {
+        this._destroy$.next(true);
+        this._destroy$.unsubscribe();
+        this._currentRefreshQuery$.next(null);
+        if (this._config.refreshConfig?.cookieName) {
+            this._deleteCookie();
+        }
+    }
+    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;
+        this._setCookie();
+    }
+    disableCookie() {
+        if (!this._config.refreshConfig?.cookieName) {
+            throw new Error('No cookie name was provided');
+        }
+        this._config.refreshConfig.cookieEnabled = false;
+        this._deleteCookie();
+    }
+    _setCookie() {
+        if (!this._config.refreshConfig?.cookieName || !this.tokens.refreshToken)
+            return;
+        setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken, this._config.refreshConfig.cookieExpiresInDays, this._config.refreshConfig.cookieDomain, this._config.refreshConfig.cookiePath, this._config.refreshConfig.cookieSameSite);
+    }
+    _deleteCookie() {
+        if (!this._config.refreshConfig?.cookieName)
+            return;
+        deleteCookie(this._config.refreshConfig.cookieName, this._config.refreshConfig.cookiePath, this._config.refreshConfig.cookieDomain);
+    }
+    _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;
+        }
+    }
+    /**
+     * @internal
+     */
+    _refreshQuery() {
+        const currentQuery = this._currentRefreshQuery$.getValue();
+        if (isQueryStateLoading(currentQuery?.rawState)) {
+            return currentQuery;
+        }
+        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({
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        token: state.response['token'],
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        refreshToken: state.response['refreshToken'],
+                    });
+                }
+                const cookieEnabled = this._config.refreshConfig?.cookieEnabled ?? true;
+                if (this._config.refreshConfig?.cookieName && this.tokens.refreshToken && cookieEnabled) {
+                    this._setCookie();
+                }
+                this._prepareForRefresh();
+            }
+            else if (isQueryStateFailure(state)) {
+                this._tokens$.next({ token: null, refreshToken: null });
+                if (this._config.refreshConfig?.cookieName) {
+                    this._deleteCookie();
+                }
+            }
+        }), takeUntilResponse(), takeUntil(this._destroy$))
+            .subscribe();
+        return query;
+    }
+}
+
+const isClassValidatorError = (error) => {
+    return typeof error === 'object' && error !== null && 'statusCode' in error && 'message' in error && 'error' in error;
+};
+
+class QueryDirective {
+    constructor() {
+        this._mainTemplateRef = inject(TemplateRef);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._errorHandler = inject(ErrorHandler);
+        this._cdr = inject(ChangeDetectorRef);
+        this._isMainViewCreated = false;
+        this._subscription = null;
+        this._viewContext = {
+            $implicit: null,
+            etQuery: null,
+            loading: false,
+            refreshing: false,
+            error: null,
+            progress: null,
+            scope: null,
+            query: 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;
+    }
+    ngOnInit() {
+        this._renderMainView();
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    _subscribeToQuery() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+        const query = extractQuery(this.query);
+        if (!query) {
+            this._viewContext.$implicit = null;
+            this._viewContext.etQuery = null;
+            this._viewContext.loading = false;
+            this._viewContext.refreshing = false;
+            this._viewContext.error = null;
+            this._viewContext.progress = null;
+            this._viewContext.scope = null;
+            this._viewContext.query = null;
+            return;
+        }
+        if (isQueryStatePrepared(query.rawState) || isQueryStateCancelled(query.rawState)) {
+            query.execute();
+        }
+        const sub = query.state$.pipe(tap((state) => this._updateView(state))).subscribe();
+        this._viewContext.scope = isQueryCollection(query) ? query.type : null;
+        this._viewContext.query = query;
+        this._subscription = sub;
+    }
+    _updateView(state) {
+        if (isQueryStateLoading(state)) {
+            this._viewContext.progress = state.progress ?? null;
+            this._viewContext.refreshing = state.meta.triggeredVia === 'auto' || state.meta.triggeredVia === 'poll';
+            if (!this._viewContext.refreshing) {
+                this._viewContext.loading = true;
+            }
+        }
+        else {
+            this._viewContext.loading = false;
+            this._viewContext.refreshing = false;
+            this._viewContext.progress = null;
+        }
+        if (isQueryStateSuccess(state)) {
+            this._viewContext.etQuery = state.response;
+            this._viewContext.$implicit = state.response;
+        }
+        else if (!this.cache) {
+            this._viewContext.etQuery = null;
+            this._viewContext.$implicit = null;
+        }
+        if (isQueryStateFailure(state)) {
+            this._viewContext.error = state.error;
+            this._errorHandler.handleError(state.error);
+        }
+        else {
+            this._viewContext.error = null;
+        }
+        this._cdr.markForCheck();
+    }
+    _renderMainView() {
+        if (!this._isMainViewCreated) {
+            this._isMainViewCreated = true;
+            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: QueryDirective, isStandalone: true, selector: "[etQuery]", inputs: { query: ["etQuery", "query"], cache: ["etQueryCache", "cache"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etQuery]',
+                    standalone: true,
+                }]
+        }], propDecorators: { query: [{
+                type: Input,
+                args: ['etQuery']
+            }], cache: [{
+                type: Input,
+                args: ['etQueryCache']
+            }] } });
+
+class InfinityQuery {
+    get currentPage$() {
+        return this._currentPage$.asObservable();
+    }
+    get currentPage() {
+        return this._currentPage$.getValue();
+    }
+    get currentCalculatedPage$() {
+        return this._currentCalculatedPage$.asObservable();
+    }
+    get currentCalculatedPage() {
+        return this._currentCalculatedPage$.getValue();
+    }
+    get totalPages$() {
+        return this._totalPages$.asObservable();
+    }
+    get totalPages() {
+        return this._totalPages$.getValue();
+    }
+    get itemsPerPage$() {
+        return this._itemsPerPage$.asObservable();
+    }
+    get itemsPerPage() {
+        return this._itemsPerPage$.getValue();
+    }
+    get data$() {
+        return this._data$;
+    }
+    get currentQuery$() {
+        return this._lastQuery$;
+    }
+    constructor(_config, _destroy$) {
+        this._config = _config;
+        this._destroy$ = _destroy$;
+        this._queries$ = new BehaviorSubject([]);
+        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._data$ = this._queries$.pipe(switchMap((queries) => {
+            if (!queries.length) {
+                return of([]);
+            }
+            return combineLatest(queries.map((query) => query.state$.pipe(filterSuccess(), map((state) => ({ state, query })))));
+        }), tap((stateMaps) => {
+            const lastState = stateMaps[stateMaps.length - 1]?.state;
+            const lastQuery = stateMaps[stateMaps.length - 1]?.query;
+            if (!lastState || !lastQuery) {
+                return;
+            }
+            const totalPages = this._config.response.totalPagesExtractor?.({
+                response: lastState.response,
+                itemsPerPage: this.itemsPerPage,
+                args: lastQuery._arguments,
+            }) ??
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                lastState.response?.totalPages ??
+                null;
+            this._totalPages$.next(totalPages);
+        }), map((stateMaps) => {
+            if (!stateMaps.length) {
+                return null;
+            }
+            const fullData = stateMaps.reduce((acc, stateMap) => {
+                const valExtractFn = this._config?.response?.valueExtractor;
+                let data = valExtractFn
+                    ? valExtractFn?.(stateMap.state.response)
+                    : stateMap.state.response;
+                if (this._config.response.reverse) {
+                    data = [...data].reverse();
+                }
+                if (this._config.response.appendItemsTo === 'start') {
+                    acc.unshift(...data);
+                }
+                else {
+                    acc.push(...data);
+                }
+                return acc;
+            }, 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            []);
+            return fullData;
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this._lastQuery$ = this._queries$.pipe(map((queries) => queries[queries.length - 1] ?? null), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    nextPage() {
+        const newPage = (this._currentPage$.value ?? 0) + 1;
+        const calculatedPage = this._config?.pageParam?.valueCalculator?.({
+            page: newPage,
+            totalPages: this.totalPages,
+            itemsPerPage: this.itemsPerPage,
+        }) ?? newPage;
+        if (this.totalPages !== null && newPage > 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();
+        if (this._config.pollingInterval) {
+            query.poll({ interval: this._config.pollingInterval, takeUntil: this._destroy$ });
+        }
+        this._queries$.next([...this._queries$.value, query]);
+        this._currentPage$.next(newPage);
+        this._currentCalculatedPage$.next(calculatedPage);
+    }
+    reset(newConfig) {
+        this._config = { ...this._config, ...(newConfig ?? {}) };
+        this._currentPage$.next(null);
+        this._currentCalculatedPage$.next(null);
+        this._totalPages$.next(null);
+        this._itemsPerPage$.next(this._config.limitParam?.value ?? 10);
+        this._queries$.next([]);
+        this.nextPage();
+    }
+    _prepareArgs(config, page) {
+        const pageParamLocation = this._getPageParamLocation(config?.pageParam?.location);
+        const pageArgs = {
+            [pageParamLocation]: {
+                [config?.pageParam?.key ?? 'page']: page,
+            },
+        };
+        const limitParamLocation = this._getPageParamLocation(config?.limitParam?.location);
+        const limitArgs = {
+            [limitParamLocation]: {
+                [config?.limitParam?.key ?? 'limit']: config?.limitParam?.value ?? 10,
+            },
+        };
+        const defaultConfig = config?.defaultArgs ?? {};
+        const mergedArgs = pageParamLocation === limitParamLocation
+            ? {
+                ...defaultConfig,
+                [pageParamLocation]: {
+                    ...(config?.defaultArgs?.[pageParamLocation] ?? {}),
+                    ...pageArgs[limitParamLocation],
+                    ...limitArgs[limitParamLocation],
+                },
+            }
+            : {
+                ...defaultConfig,
+                [pageParamLocation]: {
+                    ...(config?.defaultArgs?.[pageParamLocation] ?? {}),
+                    ...pageArgs[pageParamLocation],
+                },
+                [limitParamLocation]: {
+                    ...(config?.defaultArgs?.[limitParamLocation] ?? {}),
+                    ...limitArgs[limitParamLocation],
+                },
+            };
+        return mergedArgs;
+    }
+    _getPageParamLocation(location) {
+        const loc = location ?? 'query';
+        switch (loc) {
+            case 'path':
+                return 'pathParams';
+            case 'query':
+                return 'queryParams';
+            case 'body':
+                return 'body';
+            case 'header':
+                return 'headers';
+            case 'variable':
+                return 'variables';
+            default:
+                throw new Error(`Invalid pageParamLocation: ${loc}`);
+        }
+    }
+}
+
+const createInfinityQueryConfig = (config) => config;
+const skipPaginationPageParamCalculator = ({ page, itemsPerPage }) => itemsPerPage * (page - 1);
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const INFINITY_QUERY_TOKEN = new InjectionToken('INFINITY_QUERY_TOKEN');
+class InfinityQueryDirective {
+    get infinityQuery() {
+        return this._infinityQuery;
+    }
+    set infinityQuery(v) {
+        this._cleanup();
+        this._infinityQuery = v;
+        this._infinityQueryInstance = this._setupInfinityQuery(v);
+        this._infinityQueryInstance.nextPage();
+    }
+    get context() {
+        return this._viewContext;
+    }
+    get instance() {
+        return this._infinityQueryInstance;
+    }
+    get data$() {
+        return this._data$.asObservable();
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    constructor() {
+        this._queryConfigChanged$ = new Subject();
+        this._viewContext = {
+            $implicit: null,
+            etInfinityQuery: null,
+            loading: false,
+            error: null,
+            isFirstLoad: false,
+            canLoadMore: false,
+            currentPage: null,
+            currentCalculatedPage: null,
+            totalPages: null,
+            itemsPerPage: null,
+            currentQuery: null,
+        };
+        this._infinityQueryInstance = null;
+        this._destroy$ = createDestroy();
+        this._cdr = inject(ChangeDetectorRef);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._mainTemplateRef = inject((TemplateRef));
+        this._errorHandler = inject(ErrorHandler);
+        this._delayable = inject(DelayableDirective, { host: true });
+        this._data$ = new BehaviorSubject([]);
+        this.data = toSignal(this._data$, { requireSync: true });
+        this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);
+    }
+    _setupInfinityQuery(config) {
+        const instance = new InfinityQuery(config, this._destroy$);
+        combineLatest([
+            instance.currentQuery$.pipe(switchQueryState(), withLatestFrom(instance.currentQuery$)),
+            this._delayable.isDelayed$,
+            instance.data$,
+        ])
+            .pipe(tap(([[state, currentQuery], isDelayed, infinityArray]) => {
+            this._viewContext.currentPage = instance.currentPage;
+            this._viewContext.totalPages = instance.totalPages;
+            this._viewContext.itemsPerPage = instance.itemsPerPage;
+            this._viewContext.canLoadMore =
+                (instance.totalPages !== null &&
+                    instance.currentPage !== null &&
+                    instance.totalPages > instance.currentPage) ||
+                    false;
+            this._viewContext.currentCalculatedPage = instance.currentCalculatedPage;
+            this._viewContext.currentQuery = currentQuery;
+            if (isQueryStateLoading(state) || isDelayed || !infinityArray) {
+                this._viewContext.loading = state ? state.meta.triggeredVia !== 'poll' : true;
+                this._viewContext.error = null;
+                this._viewContext.isFirstLoad = this.context.etInfinityQuery === null;
+            }
+            else if (isQueryStateFailure(state)) {
+                this._viewContext.loading = false;
+                this._viewContext.error = state.error;
+                this._viewContext.isFirstLoad = false;
+                this._errorHandler.handleError(state.error);
+            }
+            else if (isQueryStateSuccess(state)) {
+                this._viewContext.loading = false;
+                this._viewContext.error = null;
+                this._viewContext.isFirstLoad = false;
+                this._viewContext.etInfinityQuery = this._viewContext.$implicit =
+                    infinityArray;
+                this._data$.next(infinityArray);
+            }
+            this._cdr.markForCheck();
+        }), takeUntil(this._destroy$), takeUntil(this._queryConfigChanged$))
+            .subscribe();
+        return instance;
+    }
+    loadNextPage() {
+        if (!this._infinityQueryInstance) {
+            return;
+        }
+        if (this._viewContext.loading) {
+            return;
+        }
+        this._infinityQueryInstance.nextPage();
+    }
+    reset(newConfig) {
+        if (!this._infinityQueryInstance) {
+            return;
+        }
+        this._infinityQueryInstance.reset(newConfig);
+    }
+    _cleanup() {
+        this._queryConfigChanged$.next(true);
+        this._viewContext.loading = false;
+        this._viewContext.error = null;
+        this._viewContext.etInfinityQuery = null;
+        this._viewContext.$implicit = null;
+        this._viewContext.isFirstLoad = false;
+        this._viewContext.canLoadMore = false;
+        this._viewContext.currentPage = null;
+        this._viewContext.itemsPerPage = null;
+        this._viewContext.totalPages = null;
+        this._viewContext.currentQuery = null;
+        this._data$.next([]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: InfinityQueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: InfinityQueryDirective, isStandalone: true, selector: "[etInfinityQuery]", inputs: { infinityQuery: ["etInfinityQuery", "infinityQuery"] }, providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }], exportAs: ["etInfinityQuery"], hostDirectives: [{ directive: i1.DelayableDirective }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: InfinityQueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etInfinityQuery]',
+                    exportAs: 'etInfinityQuery',
+                    standalone: true,
+                    providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }],
+                    hostDirectives: [DelayableDirective],
+                }]
+        }], ctorParameters: () => [], propDecorators: { infinityQuery: [{
+                type: Input,
+                args: ['etInfinityQuery']
+            }] } });
+
+class InfinityQueryTriggerDirective {
+    constructor() {
+        this._elementRef = inject((ElementRef));
+        this._infinityQuery = inject(INFINITY_QUERY_TOKEN);
+        this._destroy = new Subject();
+        this._observer = null;
+        this.click$ = fromEvent(this._elementRef.nativeElement, 'click');
+        this.scrollContainerSelector = null;
+    }
+    ngOnInit() {
+        const isInteractive = this._elementRef.nativeElement.tagName === 'BUTTON';
+        if (isInteractive) {
+            this.click$.pipe(takeUntil(this._destroy)).subscribe(() => this._infinityQuery.loadNextPage());
+        }
+        else {
+            this._setupIntersectionObserver();
+        }
+    }
+    ngOnDestroy() {
+        this._destroy.next(true);
+        this._destroy.unsubscribe();
+        this._observer?.disconnect();
+    }
+    _setupIntersectionObserver() {
+        this._observer = new IntersectionObserver((entries) => {
+            const entry = entries[0];
+            if (!entry)
+                return;
+            if (entry.isIntersecting && !this._infinityQuery.context.loading) {
+                this._infinityQuery.loadNextPage();
+            }
+        }, {
+            root: this.scrollContainerSelector ? document.querySelector(this.scrollContainerSelector) : null,
+            rootMargin: '0px',
+            threshold: [0.25, 0.5, 0.75, 1],
+        });
+        this._observer.observe(this._elementRef.nativeElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: InfinityQueryTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: InfinityQueryTriggerDirective, isStandalone: true, selector: "[etInfinityQueryTrigger], et-infinity-query-trigger", inputs: { scrollContainerSelector: "scrollContainerSelector" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: InfinityQueryTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etInfinityQueryTrigger], et-infinity-query-trigger',
+                    standalone: true,
+                }]
+        }], propDecorators: { scrollContainerSelector: [{
+                type: Input
+            }] } });
+
+class QueryShortNamePipe {
+    transform(value) {
+        const route = value._routeWithParams;
+        if (typeof route === 'string') {
+            // given an url that looks like this: https://api.github.com/repos/EladBezalel/etimo-achievements or https://api.github.com/repos/EladBezalel/etimo-achievements?test=1&test2=2
+            // we want to extract the last 3 parts of the url, so we get: repos/EladBezalel/etimo-achievements
+            const parts = route.split('/');
+            if (parts.length > 3) {
+                return `.../${parts.slice(parts.length - 3).join('/')}`;
+            }
+            return route;
+        }
+        return route;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryShortNamePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: QueryShortNamePipe, isStandalone: true, name: "queryShortName" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryShortNamePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'queryShortName', standalone: true }]
+        }] });
+
+const QUERY_CLIENT_DEVTOOLS_TOKEN = new InjectionToken('QUERY_CLIENT_DEVTOOLS_TOKEN');
+const provideQueryClientForDevtools = (queryClient) => {
+    if (!isDevMode()) {
+        console.warn('You are using the Query Devtools in production mode. This increases the size of your bundle and should only be used for development purposes.');
+    }
+    return {
+        provide: QUERY_CLIENT_DEVTOOLS_TOKEN,
+        useValue: queryClient,
+        multi: true,
+    };
+};
+
+class QueryDevtoolsComponent {
+    constructor() {
+        this._cdr = inject(ChangeDetectorRef);
+        this._destroy$ = createDestroy();
+        this.queryClientConfigs = inject(QUERY_CLIENT_DEVTOOLS_TOKEN);
+        this.isOpen = signal(false);
+        this.isTranslucent = signal(false);
+        this.snapLayout = signal('full');
+        this.queryListMode = signal('live');
+        this.viewMode = signal('query');
+        this.showResponse = signal(false);
+        this.showRawResponse = signal(false);
+        this.showQueryConfig = signal(false);
+        this.showEntityStoreValue = signal(false);
+        this.showArguments = signal(false);
+        this.selectedClientIdCtrl = new FormControl(0);
+        this.selectedClientId = toSignal(this.selectedClientIdCtrl.valueChanges.pipe(startWith(this.selectedClientIdCtrl.value)));
+        this.selectedQueryId = signal(null);
+        this.selectedClientConfig = computed(() => {
+            if (this.queryClientConfigs.length === 1) {
+                return this.queryClientConfigs[0];
+            }
+            const index = this.selectedClientId() ?? 0;
+            const cfg = this.queryClientConfigs[index];
+            if (!cfg) {
+                return this.queryClientConfigs[0];
+            }
+            return cfg;
+        });
+        this.queryStore = computed(() => {
+            const config = this.selectedClientConfig();
+            return config.client._store;
+        });
+        this.queryStore$ = toObservable(this.queryStore);
+        this._queries$ = new BehaviorSubject([]);
+        this.queries = toSignal(this._queries$);
+        this.selectedQuery = computed(() => {
+            const id = this.selectedQueryId();
+            const mode = this.queryListMode();
+            if (id === null || !mode) {
+                return null;
+            }
+            if (mode === 'live') {
+                return this.queries()?.find((q) => q._id === id) ?? null;
+            }
+            return this.queryHistory$.getValue()?.find((q) => q._id === id) ?? null;
+        });
+        this.selectedQuery$ = toObservable(this.selectedQuery);
+        this.selectedQueryEntityStore = computed(() => {
+            const query = this.selectedQuery();
+            if (!query)
+                return null;
+            return query.store;
+        });
+        this.selectedQueryEntityStore$ = toObservable(this.selectedQueryEntityStore);
+        this.selectedQueryEntityStoreValue$ = this.selectedQueryEntityStore$.pipe(switchMap((s) => s?._change$.pipe(startWith(''), map(() => {
+            if (!s._dictionary)
+                return null;
+            return Array.from(s._dictionary).reduce((obj, [key, value]) => {
+                obj[key] = value;
+                return obj;
+            }, {});
+        })) ?? of(null)));
+        this.queryHistory$ = new BehaviorSubject([]);
+        this.stringifiedQueryConfig = computed(() => {
+            const query = this.selectedQuery();
+            if (!query)
+                return null;
+            const cfg = query._queryConfig;
+            const route = typeof cfg.route === 'string' ? cfg.route : cfg.route ? cfg.route({}).replace(/undefined/g, ':param') : null;
+            const sharedCfg = {
+                method: cfg.method,
+                secure: cfg.secure,
+                route,
+                reportProgress: cfg.reportProgress,
+                responseType: cfg.responseType,
+                withCredentials: cfg.withCredentials,
+                autoRefreshOn: cfg.autoRefreshOn,
+                enableSmartPolling: cfg.enableSmartPolling,
+                hasEntityStore: !!cfg.entity,
+            };
+            if (isGqlQueryConfig(cfg)) {
+                return {
+                    ...sharedCfg,
+                    query: cfg.query,
+                    transferVia: cfg.transferVia,
+                };
+            }
+            return {
+                ...sharedCfg,
+            };
+        });
+        this.authProvider = toSignal(toObservable(this.selectedClientConfig).pipe(switchMap((c) => c.client.authProvider$)));
+        this.authProviderDetails = computed(() => {
+            const provider = this.authProvider();
+            if (!provider)
+                return null;
+            if (provider instanceof CustomHeaderAuthProvider) {
+                return {
+                    type: 'CustomHeaderAuthProvider',
+                    header: () => provider.header,
+                    provider: provider,
+                    config: {
+                        name: provider._config.name,
+                        value: provider._config.value,
+                    },
+                };
+            }
+            else if (provider instanceof BasicAuthProvider) {
+                return {
+                    type: 'BasicAuthProvider',
+                    header: () => provider.header,
+                    provider: provider,
+                    config: {
+                        username: provider._config.username,
+                        password: provider._config.password,
+                    },
+                };
+            }
+            else if (isBearerAuthProvider(provider)) {
+                const refreshCfg = provider._config.refreshConfig;
+                return {
+                    type: 'BearerAuthProvider',
+                    header: () => provider.header,
+                    provider: provider,
+                    config: {
+                        token: provider._config.token,
+                        refreshConfig: {
+                            refreshOnUnauthorizedResponse: refreshCfg?.refreshOnUnauthorizedResponse ?? 'true (default)',
+                            token: refreshCfg?.token,
+                            cookieName: refreshCfg?.cookieName,
+                            cookieDomain: refreshCfg?.cookieDomain ?? 'current origin (default)',
+                            cookieExpiresInDays: refreshCfg?.cookieExpiresInDays ?? '30 (default)',
+                            cookiePath: refreshCfg?.cookiePath ?? '/ (default)',
+                            cookieEnabled: refreshCfg?.cookieEnabled ?? 'true (default)',
+                            cookieSameSite: refreshCfg?.cookieSameSite ?? 'lax (default)',
+                            refreshBuffer: refreshCfg?.refreshBuffer ?? '30000 (default)',
+                            expiresInPropertyName: refreshCfg?.expiresInPropertyName ?? 'exp (default)',
+                            strategy: refreshCfg?.strategy ?? 'AuthBearerRefreshStrategy.BeforeExpiration (default)',
+                            requestArgsAdapter: refreshCfg?.requestArgsAdapter ? 'custom' : 'default',
+                            responseAdapter: refreshCfg?.responseAdapter ? 'custom' : 'default',
+                        },
+                    },
+                };
+            }
+            else {
+                return {
+                    type: 'UnknownAuthProvider',
+                    header: () => provider.header,
+                    provider: provider,
+                    config: {},
+                };
+            }
+        });
+        this.trackByClient = (_, { client }) => client.config.baseRoute;
+        this.trackByQuery = (_, { _id }) => _id;
+        this.selectedClientIdCtrl.valueChanges
+            .pipe(tap(() => this.clearQueryHistory()), takeUntil(this._destroy$))
+            .subscribe();
+        this.selectedQuery$
+            .pipe(switchMap((q) => q?._dependentsChanged$ ?? of(null)), tap(() => this._cdr.markForCheck()), takeUntilDestroyed())
+            .subscribe();
+        toObservable(this.authProviderDetails)
+            .pipe(switchMap((ap) => (ap?.type === 'BearerAuthProvider' ? ap.provider.tokens$ : of(null))))
+            .pipe(tap(() => this._cdr.markForCheck()), takeUntilDestroyed())
+            .subscribe();
+        this.queryStore$
+            .pipe(switchMap((s) => s.storeChange$.pipe(startWith(''), map(() => s._store), tap((s) => {
+            untracked(() => {
+                this._queries$.next(Array.from(s.values()));
+            });
+        }), takeUntil(this._destroy$))))
+            .subscribe();
+        this.queryStore$
+            .pipe(switchMap((s) => s.queryCreated$.pipe(tap((query) => {
+            const currentHistory = this.queryHistory$.getValue();
+            if (!currentHistory)
+                return;
+            const currentHistoryClone = [...currentHistory];
+            if (!currentHistory.some((q) => q._id === query._id)) {
+                currentHistoryClone.unshift(query);
+            }
+            currentHistoryClone.splice(50);
+            this.queryHistory$.next(currentHistoryClone);
+        }), takeUntil(this._destroy$))))
+            .subscribe();
+        this._queries$
+            .pipe(tap((queries) => {
+            const currentHistory = this.queryHistory$.getValue();
+            if (!queries || !currentHistory)
+                return;
+            const currentHistoryClone = [...currentHistory];
+            for (const query of queries) {
+                if (!currentHistoryClone.some((q) => q._id === query._id)) {
+                    currentHistoryClone.unshift(query);
+                }
+            }
+            currentHistoryClone.splice(50);
+            this.queryHistory$.next(currentHistoryClone);
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        effect(() => {
+            const devtoolConfig = {
+                isOpen: this.isOpen(),
+                isTranslucent: this.isTranslucent(),
+                snapLayout: this.snapLayout(),
+                showResponse: this.showResponse(),
+                showRawResponse: this.showRawResponse(),
+                showQueryConfig: this.showQueryConfig(),
+                showEntityStoreValue: this.showEntityStoreValue(),
+                showArguments: this.showArguments(),
+                selectedClientId: this.selectedClientId(),
+                selectedQueryPath: this.selectedQueryId(),
+                queryListMode: this.queryListMode(),
+                viewMode: this.viewMode(),
+            };
+            window.localStorage.setItem('ethlete:query:devtools', JSON.stringify(devtoolConfig));
+        }, { allowSignalWrites: true });
+        const initialConfig = window.localStorage.getItem('ethlete:query:devtools');
+        if (initialConfig) {
+            const parsed = JSON.parse(initialConfig);
+            this.isOpen.set(parsed.isOpen ?? false);
+            this.isTranslucent.set(parsed.isTranslucent ?? false);
+            this.snapLayout.set(parsed.snapLayout ?? 'full');
+            this.showResponse.set(parsed.showResponse ?? false);
+            this.showRawResponse.set(parsed.showRawResponse ?? false);
+            this.showQueryConfig.set(parsed.showQueryConfig ?? false);
+            this.showEntityStoreValue.set(parsed.showEntityStoreValue ?? false);
+            this.showArguments.set(parsed.showArguments ?? false);
+            this.selectedClientIdCtrl.setValue(parsed.selectedClientId ?? 0);
+            this.selectedQueryId.set(parsed.selectedQueryPath ?? null);
+            this.queryListMode.set(parsed.queryListMode ?? 'live');
+            this.viewMode.set(parsed.viewMode ?? 'query');
+        }
+    }
+    toggleOpen() {
+        this.isOpen.set(!this.isOpen());
+    }
+    toggleTranslucent() {
+        this.isTranslucent.set(!this.isTranslucent());
+    }
+    toggleShowResponse() {
+        this.showResponse.set(!this.showResponse());
+        nextFrame(() => {
+            this._cdr.markForCheck();
+        });
+    }
+    toggleShowQueryConfig() {
+        this.showQueryConfig.set(!this.showQueryConfig());
+    }
+    toggleShowRawResponse() {
+        this.showRawResponse.set(!this.showRawResponse());
+    }
+    toggleShowEntityStoreValue() {
+        this.showEntityStoreValue.set(!this.showEntityStoreValue());
+    }
+    toggleShowArguments() {
+        this.showArguments.set(!this.showArguments());
+    }
+    selectSnapLayout(layout) {
+        this.snapLayout.set(layout);
+    }
+    selectQueryListMode(mode) {
+        this.queryListMode.set(mode);
+    }
+    selectViewMode(mode) {
+        this.viewMode.set(mode);
+    }
+    selectQuery(query) {
+        this.selectedQueryId.set(query._id);
+    }
+    clearQueryHistory() {
+        this.queryHistory$.next([]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryDevtoolsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.1.1", type: QueryDevtoolsComponent, isStandalone: true, selector: "et-query-devtools", host: { classAttribute: "et-query-devtools" }, ngImport: i0, template: "@if (!isOpen()) {\n  <button (click)=\"toggleOpen()\" class=\"et-query-devtools-open-btn et-qd-chip\">Query Devtools</button>\n}\n\n@if (isOpen()) {\n  <div\n    [class.et-query-devtools-container--transparent]=\"isTranslucent()\"\n    class=\"et-query-devtools-container et-query-devtools-container--snap-{{ snapLayout() }}\"\n  >\n    <header class=\"et-qd-header\">\n      <h3 class=\"et-qd-header__title\">Query Devtools</h3>\n\n      <div class=\"et-qd-header__select\">\n        <label for=\"et-query-client-instance\">Client instance</label>\n        <select [formControl]=\"selectedClientIdCtrl\" id=\"et-query-client-instance\">\n          @for (clientConfig of queryClientConfigs; track trackByClient(i, clientConfig); let i = $index) {\n            <option [value]=\"i\">\n              {{ clientConfig.displayName ?? clientConfig.client.config.baseRoute }}\n            </option>\n          }\n        </select>\n      </div>\n\n      <button (click)=\"toggleOpen()\" class=\"et-qd-btn et-qd-btn-secondary\">Close</button>\n    </header>\n\n    <div class=\"et-qd-sub-header\">\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': !isTranslucent() }\"\n        (click)=\"toggleTranslucent()\"\n        class=\"et-qd-chip et-qd-translucent-clickable\"\n      >\n        Translucent\n      </button>\n      <div class=\"et-qd-sub-header__divider\"></div>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'full' }\"\n        (click)=\"selectSnapLayout('full')\"\n        class=\"et-qd-chip\"\n      >\n        Fullscreen\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'top' }\"\n        (click)=\"selectSnapLayout('top')\"\n        class=\"et-qd-chip\"\n      >\n        Top\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'bottom' }\"\n        (click)=\"selectSnapLayout('bottom')\"\n        class=\"et-qd-chip\"\n      >\n        Bottom\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'left' }\"\n        (click)=\"selectSnapLayout('left')\"\n        class=\"et-qd-chip\"\n      >\n        Left\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'right' }\"\n        (click)=\"selectSnapLayout('right')\"\n        class=\"et-qd-chip\"\n      >\n        Right\n      </button>\n    </div>\n\n    @if (selectedClientConfig(); as cfg) {\n      <div class=\"et-qd-client\">\n        <p class=\"et-qd-client__title\">{{ cfg.displayName ?? cfg.client.config.baseRoute }}</p>\n\n        <div class=\"et-qd-client__actions\">\n          <button (click)=\"cfg.client._store.refreshQueriesInUse()\" class=\"et-qd-chip\">Refresh all</button>\n          <button (click)=\"cfg.client._store.refreshQueriesInUse({ ignoreCacheValidity: true })\" class=\"et-qd-chip\">\n            Refresh all (ignore caches)\n          </button>\n          <button\n            (click)=\"cfg.client._store.refreshQueriesInUse({ ignoreCacheValidity: true, purgeUnused: true })\"\n            class=\"et-qd-chip\"\n          >\n            Refresh all (ignore caches & purge unused)\n          </button>\n        </div>\n      </div>\n    }\n\n    @if (selectedClientConfig(); as cfg) {\n      <div class=\"et-qd-queries\">\n        <p class=\"et-qd-queries__title\">Inspector</p>\n        <div class=\"et-qd-queries__actions\">\n          <button\n            [ngClass]=\"{ 'et-qd-chip-secondary': queryListMode() !== 'live' || viewMode() !== 'query' }\"\n            (click)=\"selectQueryListMode('live'); selectViewMode('query')\"\n            class=\"et-qd-chip et-qd-chip-bordered\"\n          >\n            Live Queries ({{ queries()?.length ?? 0 }})\n          </button>\n          <button\n            [ngClass]=\"{ 'et-qd-chip-secondary': queryListMode() !== 'history' || viewMode() !== 'query' }\"\n            (click)=\"selectQueryListMode('history'); selectViewMode('query')\"\n            class=\"et-qd-chip et-qd-chip-bordered\"\n          >\n            Query History ({{ (queryHistory$ | async)?.length ?? 0 }}/50)\n          </button>\n          @if (queryListMode() === 'history' && viewMode() === 'query') {\n            <div class=\"et-qd-queries__divider\"></div>\n            <button (click)=\"clearQueryHistory()\" class=\"et-qd-chip et-qd-chip-bordered\">Clear history</button>\n          }\n\n          <div class=\"et-qd-queries__divider\"></div>\n          <button\n            [ngClass]=\"{ 'et-qd-chip-secondary': viewMode() !== 'authProvider' }\"\n            (click)=\"selectViewMode('authProvider')\"\n            class=\"et-qd-chip et-qd-chip-bordered\"\n          >\n            Auth Provider\n          </button>\n        </div>\n\n        @if (viewMode() === 'query') {\n          <div class=\"et-qd-queries__browser\">\n            @if (queryListMode() === 'live') {\n              <ul class=\"et-qd-queries__browser-list\">\n                @for (query of queries(); track trackByQuery($index, query)) {\n                  <li>\n                    <button\n                      [class.et-qd-query--active]=\"selectedQuery()?._id === query._id\"\n                      (click)=\"selectQuery(query)\"\n                    >\n                      <span> {{ query._queryConfig.method }}</span>\n                      <span> {{ query | queryShortName }}</span>\n                    </button>\n                  </li>\n                }\n              </ul>\n            }\n            @if (queryListMode() === 'history') {\n              <ul class=\"et-qd-queries__browser-list\">\n                @for (query of queryHistory$ | async; track trackByQuery($index, query)) {\n                  <li>\n                    <button\n                      [class.et-qd-query--active]=\"selectedQuery()?._id === query._id\"\n                      (click)=\"selectQuery(query)\"\n                    >\n                      <span> {{ query._queryConfig.method }}</span>\n                      <span> {{ query | queryShortName }}</span>\n                    </button>\n                  </li>\n                }\n              </ul>\n            }\n            <div class=\"et-qd-queries__browser-detail\">\n              @if (selectedQuery(); as query) {\n                <p class=\"et-qd-queries__browser-detail__title\">\n                  {{ query._queryConfig.method }} {{ query._routeWithParams }}\n                </p>\n\n                <div class=\"et-qd-queries__actions\">\n                  <button (click)=\"query.execute()\" class=\"et-qd-chip et-qd-chip-bordered\">Execute</button>\n                  <button (click)=\"query.execute({ skipCache: true })\" class=\"et-qd-chip et-qd-chip-bordered\">\n                    Execute (ignore cache)\n                  </button>\n\n                  <button (click)=\"query.abort()\" class=\"et-qd-chip et-qd-chip-bordered\">Abort</button>\n                  <div class=\"et-qd-queries__divider\"></div>\n                  <button\n                    [ngClass]=\"{ 'et-qd-chip-secondary': !query.isPolling }\"\n                    (click)=\"query.poll({ interval: 5000, takeUntil: _destroy$ })\"\n                    class=\"et-qd-chip et-qd-chip-bordered\"\n                  >\n                    Poll\n                  </button>\n\n                  <button\n                    [ngClass]=\"{ 'et-qd-chip-secondary': query.isPolling }\"\n                    (click)=\"query.stopPolling()\"\n                    class=\"et-qd-chip et-qd-chip-bordered\"\n                  >\n                    Stop polling\n                  </button>\n                  @if (query.isPolling || query._isPollingPaused) {\n                    <button (click)=\"query.pausePolling()\" class=\"et-qd-chip et-qd-chip-secondary et-qd-chip-bordered\">\n                      Pause polling\n                    </button>\n                    <button (click)=\"query.resumePolling()\" class=\"et-qd-chip et-qd-chip-secondary et-qd-chip-bordered\">\n                      Resume polling\n                    </button>\n                  }\n                </div>\n\n                <div class=\"et-qd-list\">\n                  <div class=\"et-qd-list-item\">\n                    <p>State type</p>\n                    <pre>{{ query.rawState.type }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Dependents</p>\n                    <pre>{{ query._dependents | json }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is expired</p>\n                    <pre>{{ query.isExpired }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is in use</p>\n                    <pre>{{ query.isInUse }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Subscriber count</p>\n                    <pre>{{ query._subscriberCount }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is polling</p>\n                    <pre>{{ query.isPolling }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is polling paused</p>\n                    <pre>{{ query._isPollingPaused }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Enable smart polling</p>\n                    <pre>{{ query._enableSmartPolling }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Query store key</p>\n                    <pre>{{ query._queryStoreKey }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Arguments</p>\n\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showArguments() }\"\n                        (click)=\"toggleShowArguments()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showArguments()) {\n                      <pre>{{ query._arguments | json }}</pre>\n                    }\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>State</p>\n                    <p><i> Warning, this will cause a subscription if shown!</i></p>\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showResponse() }\"\n                        (click)=\"toggleShowResponse()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showResponse()) {\n                      <pre>{{ query.state$ | async | json }}</pre>\n                    }\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Raw state</p>\n                    <p><i> The query state unaffected by entity stores</i></p>\n\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showRawResponse() }\"\n                        (click)=\"toggleShowRawResponse()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showRawResponse()) {\n                      <pre>{{ query.rawState | json }}</pre>\n                    }\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Query config</p>\n\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showQueryConfig() }\"\n                        (click)=\"toggleShowQueryConfig()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showQueryConfig()) {\n                      <pre>{{ stringifiedQueryConfig() | json }}</pre>\n                    }\n                  </div>\n\n                  @if (!!query._queryConfig.entity) {\n                    <div class=\"et-qd-list-item\">\n                      <p>Entity store value</p>\n\n                      <div>\n                        <button\n                          [ngClass]=\"{ 'et-qd-chip-secondary': !showEntityStoreValue() }\"\n                          (click)=\"toggleShowEntityStoreValue()\"\n                          class=\"et-qd-chip et-qd-chip-bordered\"\n                        >\n                          Toggle\n                        </button>\n                      </div>\n                      @if (showEntityStoreValue()) {\n                        <pre>{{ selectedQueryEntityStoreValue$ | async | json }}</pre>\n                      }\n                    </div>\n                  }\n                </div>\n              }\n            </div>\n          </div>\n        } @else if (viewMode() === 'authProvider') {\n          <div class=\"et-qd-auth-provider__viewer\">\n            @if (authProviderDetails(); as details) {\n              <div class=\"et-qd-list\">\n                <div class=\"et-qd-list-item\">\n                  <p>Type</p>\n                  <pre>{{ details.type }}</pre>\n                </div>\n                <div class=\"et-qd-list-item\">\n                  <p>Header value</p>\n                  <pre>{{ details.header() | json }}</pre>\n                </div>\n                <div class=\"et-qd-list-item\">\n                  <p>Config</p>\n                  <pre>{{ details.config | json }}</pre>\n                </div>\n\n                @if (details.type === 'BearerAuthProvider') {\n                  <div class=\"et-qd-list-item\">\n                    <p>Tokens</p>\n                    <pre>{{ details.provider.tokens$ | async | json }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Should refresh on unauthorized response</p>\n                    <pre>{{ details.provider.shouldRefreshOnUnauthorizedResponse }}</pre>\n                  </div>\n\n                  <ng-container\n                    *etQuery=\"\n                      details.provider.currentRefreshQuery$ | async as response;\n                      loading as loading;\n                      error as error;\n                      query as query\n                    \"\n                  >\n                    <div class=\"et-qd-list-item\">\n                      <p>Refresh query response</p>\n\n                      <div>\n                        <button (click)=\"details.provider._refreshQuery()\" class=\"et-qd-chip et-qd-chip-bordered\">\n                          Refresh\n                        </button>\n                      </div>\n                      <pre>{{ response | json }}</pre>\n                    </div>\n                    <div class=\"et-qd-list-item\">\n                      <p>Refresh query loading</p>\n                      <pre>{{ loading }}</pre>\n                    </div>\n                    <div class=\"et-qd-list-item\">\n                      <p>Refresh query error</p>\n                      <pre>{{ error ?? 'null' }}</pre>\n                    </div>\n                    <div class=\"et-qd-list-item\">\n                      <p>State</p>\n                      <pre>{{ query?.state$ | async | json }}</pre>\n                    </div>\n                  </ng-container>\n                }\n              </div>\n            } @else {\n              <p>No auth provider set</p>\n            }\n          </div>\n        }\n      </div>\n    }\n  </div>\n}\n", styles: [":host{position:fixed;top:0;z-index:1000000;font-size:14px;color:#fff}.et-query-devtools-container{position:fixed;inset:0;background-color:#25292e;z-index:10000;overflow:auto;font-family:monospace;display:grid;grid-template-rows:auto auto auto minmax(0,1fr)}.et-query-devtools-container.et-query-devtools-container--transparent{opacity:.25;pointer-events:none}.et-query-devtools-container.et-query-devtools-container--transparent .et-query-devtools-translucent-btn{pointer-events:all}.et-query-devtools-container.et-query-devtools-container--snap-left{inset-inline-start:0;inset-block-start:0;inset-block-end:0;width:50%;border-right:1px solid rgb(37,41,46)}.et-query-devtools-container.et-query-devtools-container--snap-right{inset-inline-start:unset;inset-inline-end:0;inset-block-start:0;inset-block-end:0;width:50%;border-left:1px solid rgb(37,41,46)}.et-query-devtools-container.et-query-devtools-container--snap-top{inset-inline-start:0;inset-block-start:0;inset-inline-end:0;height:50%;border-bottom:1px solid rgb(37,41,46)}.et-query-devtools-container.et-query-devtools-container--snap-bottom{inset-inline-start:0;inset-block-start:unset;inset-block-end:0;inset-inline-end:0;height:50%;border-top:1px solid rgb(37,41,46)}button.et-query-devtools-open-btn{position:fixed;inset-inline-end:20px;inset-block-end:0;z-index:9999;font-family:monospace;border-radius:3px 3px 0 0;line-height:14px;font-size:12px}.et-qd-header{background-color:#00ffa1;padding:12px;display:grid;grid-template-columns:1fr auto auto;gap:12px;align-items:center}.et-qd-header__title{color:#25292e;margin:0;font-size:22px}.et-qd-header__select{display:grid;background-color:#25292e;border-radius:10px;overflow:hidden}.et-qd-header__select select{width:250px;color:#fff;padding:3px 10px 2px;border:none;background-color:#25292e;font-family:monospace}.et-qd-header__select label{padding:3px 10px;color:#25292e;font-size:12px;font-weight:700;color:#fff;border-bottom:1px solid gray}.et-qd-sub-header{background-color:#00b371;padding:12px;display:flex;gap:12px;flex-wrap:wrap}.et-qd-sub-header__divider{width:1px;background-color:#25292e}.et-qd-btn{background-color:#00ffa1;color:#25292e;border:none;padding:12px;cursor:pointer;font-size:14px;font-weight:700;text-align:center;text-decoration:none;display:inline-block;width:100%;transition:all .3s ease-in-out;font-family:monospace;border-radius:10px}.et-qd-btn:hover{background-color:#00cc81}.et-qd-btn.et-qd-btn-secondary{background-color:#25292e;color:#00ffa1}.et-qd-btn.et-qd-btn-secondary:hover{background-color:#3c424a}.et-qd-chip{background-color:#00ffa1;color:#25292e;border:none;padding:4px 9px;cursor:pointer;font-size:12px;font-weight:700;text-align:center;text-decoration:none;display:inline-block;transition:all .3s ease-in-out;font-family:monospace;border-radius:10px}.et-qd-chip:hover{background-color:#00cc81}.et-qd-chip.et-qd-chip-secondary{background-color:#25292e;color:#00ffa1}.et-qd-chip.et-qd-chip-secondary:hover{background-color:#3c424a}.et-qd-chip.et-qd-chip-bordered{border:1px solid rgb(0,255,161)}.et-qd-translucent-clickable{pointer-events:all}.et-qd-client{border-bottom:1px solid #3c424a;padding:12px}.et-qd-client__title{margin:0;font-size:14px;color:#fff;font-weight:700}.et-qd-client__actions{display:flex;gap:12px;margin-top:12px}.et-qd-queries{padding:12px;display:grid;grid-template-rows:auto auto minmax(0,1fr)}.et-qd-queries__actions{display:flex;gap:12px;margin-top:12px;margin-bottom:16px}.et-qd-queries__title{margin:0;font-size:14px;color:#fff;font-weight:700}.et-qd-queries__divider{width:1px;background-color:#3c424a}.et-qd-queries__browser{display:grid;grid-template-columns:1fr minmax(0,3fr);margin-left:-12px;margin-right:-12px;border-top:1px solid #3c424a;margin-bottom:-12px}.et-qd-queries__browser-list{border-right:1px solid #3c424a;list-style:none;padding:0;margin:0;display:grid;grid-auto-flow:row;grid-auto-rows:55px;overflow-y:auto;overflow-x:hidden}.et-qd-queries__browser-list li{margin:0}.et-qd-queries__browser-list li button{all:unset;font-family:monospace;box-sizing:border-box;width:100%;border:none;border-bottom:1px solid #3c424a;background-color:#25292e;color:#fff;text-align:left;padding:12px;height:100%;transition:all .3s ease-in-out;cursor:pointer;display:grid;grid-template-columns:auto minmax(0,1fr);gap:2px;display:block}.et-qd-queries__browser-list li button span{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.et-qd-queries__browser-list li button span:first-of-type{font-weight:700}.et-qd-queries__browser-list li button:hover,.et-qd-queries__browser-list li button.et-qd-query--active{background-color:#30363c}.et-qd-queries__browser-detail{padding:12px;overflow-y:auto;overflow-x:hidden}.et-qd-queries__browser-detail__title{margin:0;font-size:14px;color:#fff;font-weight:700}.et-qd-auth-provider__viewer{border-top:1px solid #3c424a;margin-left:-12px;margin-right:-12px;margin-bottom:-12px;padding:12px;overflow-y:auto;overflow-x:hidden}.et-qd-list{display:grid;gap:12px}.et-qd-list-item{display:grid}.et-qd-list-item p{font-weight:700;margin:0;padding-bottom:8px}.et-qd-list-item p+p{margin-top:-8px}.et-qd-list-item div+pre{margin-top:8px}.et-qd-list-item pre{margin:0;padding:4px;background-color:#0e1012;border-radius:4px;max-height:450px;overflow:auto}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "pipe", type: JsonPipe, name: "json" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$1.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1$1.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1$1.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i1$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: QueryShortNamePipe, name: "queryShortName" }, { kind: "directive", type: QueryDirective, selector: "[etQuery]", inputs: ["etQuery", "etQueryCache"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.ShadowDom }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryDevtoolsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-query-devtools', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.ShadowDom, host: {
+                        class: 'et-query-devtools',
+                    }, imports: [AsyncPipe, JsonPipe, ReactiveFormsModule, NgClass, QueryShortNamePipe, QueryDirective], template: "@if (!isOpen()) {\n  <button (click)=\"toggleOpen()\" class=\"et-query-devtools-open-btn et-qd-chip\">Query Devtools</button>\n}\n\n@if (isOpen()) {\n  <div\n    [class.et-query-devtools-container--transparent]=\"isTranslucent()\"\n    class=\"et-query-devtools-container et-query-devtools-container--snap-{{ snapLayout() }}\"\n  >\n    <header class=\"et-qd-header\">\n      <h3 class=\"et-qd-header__title\">Query Devtools</h3>\n\n      <div class=\"et-qd-header__select\">\n        <label for=\"et-query-client-instance\">Client instance</label>\n        <select [formControl]=\"selectedClientIdCtrl\" id=\"et-query-client-instance\">\n          @for (clientConfig of queryClientConfigs; track trackByClient(i, clientConfig); let i = $index) {\n            <option [value]=\"i\">\n              {{ clientConfig.displayName ?? clientConfig.client.config.baseRoute }}\n            </option>\n          }\n        </select>\n      </div>\n\n      <button (click)=\"toggleOpen()\" class=\"et-qd-btn et-qd-btn-secondary\">Close</button>\n    </header>\n\n    <div class=\"et-qd-sub-header\">\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': !isTranslucent() }\"\n        (click)=\"toggleTranslucent()\"\n        class=\"et-qd-chip et-qd-translucent-clickable\"\n      >\n        Translucent\n      </button>\n      <div class=\"et-qd-sub-header__divider\"></div>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'full' }\"\n        (click)=\"selectSnapLayout('full')\"\n        class=\"et-qd-chip\"\n      >\n        Fullscreen\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'top' }\"\n        (click)=\"selectSnapLayout('top')\"\n        class=\"et-qd-chip\"\n      >\n        Top\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'bottom' }\"\n        (click)=\"selectSnapLayout('bottom')\"\n        class=\"et-qd-chip\"\n      >\n        Bottom\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'left' }\"\n        (click)=\"selectSnapLayout('left')\"\n        class=\"et-qd-chip\"\n      >\n        Left\n      </button>\n      <button\n        [ngClass]=\"{ 'et-qd-chip-secondary': snapLayout() !== 'right' }\"\n        (click)=\"selectSnapLayout('right')\"\n        class=\"et-qd-chip\"\n      >\n        Right\n      </button>\n    </div>\n\n    @if (selectedClientConfig(); as cfg) {\n      <div class=\"et-qd-client\">\n        <p class=\"et-qd-client__title\">{{ cfg.displayName ?? cfg.client.config.baseRoute }}</p>\n\n        <div class=\"et-qd-client__actions\">\n          <button (click)=\"cfg.client._store.refreshQueriesInUse()\" class=\"et-qd-chip\">Refresh all</button>\n          <button (click)=\"cfg.client._store.refreshQueriesInUse({ ignoreCacheValidity: true })\" class=\"et-qd-chip\">\n            Refresh all (ignore caches)\n          </button>\n          <button\n            (click)=\"cfg.client._store.refreshQueriesInUse({ ignoreCacheValidity: true, purgeUnused: true })\"\n            class=\"et-qd-chip\"\n          >\n            Refresh all (ignore caches & purge unused)\n          </button>\n        </div>\n      </div>\n    }\n\n    @if (selectedClientConfig(); as cfg) {\n      <div class=\"et-qd-queries\">\n        <p class=\"et-qd-queries__title\">Inspector</p>\n        <div class=\"et-qd-queries__actions\">\n          <button\n            [ngClass]=\"{ 'et-qd-chip-secondary': queryListMode() !== 'live' || viewMode() !== 'query' }\"\n            (click)=\"selectQueryListMode('live'); selectViewMode('query')\"\n            class=\"et-qd-chip et-qd-chip-bordered\"\n          >\n            Live Queries ({{ queries()?.length ?? 0 }})\n          </button>\n          <button\n            [ngClass]=\"{ 'et-qd-chip-secondary': queryListMode() !== 'history' || viewMode() !== 'query' }\"\n            (click)=\"selectQueryListMode('history'); selectViewMode('query')\"\n            class=\"et-qd-chip et-qd-chip-bordered\"\n          >\n            Query History ({{ (queryHistory$ | async)?.length ?? 0 }}/50)\n          </button>\n          @if (queryListMode() === 'history' && viewMode() === 'query') {\n            <div class=\"et-qd-queries__divider\"></div>\n            <button (click)=\"clearQueryHistory()\" class=\"et-qd-chip et-qd-chip-bordered\">Clear history</button>\n          }\n\n          <div class=\"et-qd-queries__divider\"></div>\n          <button\n            [ngClass]=\"{ 'et-qd-chip-secondary': viewMode() !== 'authProvider' }\"\n            (click)=\"selectViewMode('authProvider')\"\n            class=\"et-qd-chip et-qd-chip-bordered\"\n          >\n            Auth Provider\n          </button>\n        </div>\n\n        @if (viewMode() === 'query') {\n          <div class=\"et-qd-queries__browser\">\n            @if (queryListMode() === 'live') {\n              <ul class=\"et-qd-queries__browser-list\">\n                @for (query of queries(); track trackByQuery($index, query)) {\n                  <li>\n                    <button\n                      [class.et-qd-query--active]=\"selectedQuery()?._id === query._id\"\n                      (click)=\"selectQuery(query)\"\n                    >\n                      <span> {{ query._queryConfig.method }}</span>\n                      <span> {{ query | queryShortName }}</span>\n                    </button>\n                  </li>\n                }\n              </ul>\n            }\n            @if (queryListMode() === 'history') {\n              <ul class=\"et-qd-queries__browser-list\">\n                @for (query of queryHistory$ | async; track trackByQuery($index, query)) {\n                  <li>\n                    <button\n                      [class.et-qd-query--active]=\"selectedQuery()?._id === query._id\"\n                      (click)=\"selectQuery(query)\"\n                    >\n                      <span> {{ query._queryConfig.method }}</span>\n                      <span> {{ query | queryShortName }}</span>\n                    </button>\n                  </li>\n                }\n              </ul>\n            }\n            <div class=\"et-qd-queries__browser-detail\">\n              @if (selectedQuery(); as query) {\n                <p class=\"et-qd-queries__browser-detail__title\">\n                  {{ query._queryConfig.method }} {{ query._routeWithParams }}\n                </p>\n\n                <div class=\"et-qd-queries__actions\">\n                  <button (click)=\"query.execute()\" class=\"et-qd-chip et-qd-chip-bordered\">Execute</button>\n                  <button (click)=\"query.execute({ skipCache: true })\" class=\"et-qd-chip et-qd-chip-bordered\">\n                    Execute (ignore cache)\n                  </button>\n\n                  <button (click)=\"query.abort()\" class=\"et-qd-chip et-qd-chip-bordered\">Abort</button>\n                  <div class=\"et-qd-queries__divider\"></div>\n                  <button\n                    [ngClass]=\"{ 'et-qd-chip-secondary': !query.isPolling }\"\n                    (click)=\"query.poll({ interval: 5000, takeUntil: _destroy$ })\"\n                    class=\"et-qd-chip et-qd-chip-bordered\"\n                  >\n                    Poll\n                  </button>\n\n                  <button\n                    [ngClass]=\"{ 'et-qd-chip-secondary': query.isPolling }\"\n                    (click)=\"query.stopPolling()\"\n                    class=\"et-qd-chip et-qd-chip-bordered\"\n                  >\n                    Stop polling\n                  </button>\n                  @if (query.isPolling || query._isPollingPaused) {\n                    <button (click)=\"query.pausePolling()\" class=\"et-qd-chip et-qd-chip-secondary et-qd-chip-bordered\">\n                      Pause polling\n                    </button>\n                    <button (click)=\"query.resumePolling()\" class=\"et-qd-chip et-qd-chip-secondary et-qd-chip-bordered\">\n                      Resume polling\n                    </button>\n                  }\n                </div>\n\n                <div class=\"et-qd-list\">\n                  <div class=\"et-qd-list-item\">\n                    <p>State type</p>\n                    <pre>{{ query.rawState.type }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Dependents</p>\n                    <pre>{{ query._dependents | json }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is expired</p>\n                    <pre>{{ query.isExpired }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is in use</p>\n                    <pre>{{ query.isInUse }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Subscriber count</p>\n                    <pre>{{ query._subscriberCount }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is polling</p>\n                    <pre>{{ query.isPolling }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Is polling paused</p>\n                    <pre>{{ query._isPollingPaused }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Enable smart polling</p>\n                    <pre>{{ query._enableSmartPolling }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Query store key</p>\n                    <pre>{{ query._queryStoreKey }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Arguments</p>\n\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showArguments() }\"\n                        (click)=\"toggleShowArguments()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showArguments()) {\n                      <pre>{{ query._arguments | json }}</pre>\n                    }\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>State</p>\n                    <p><i> Warning, this will cause a subscription if shown!</i></p>\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showResponse() }\"\n                        (click)=\"toggleShowResponse()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showResponse()) {\n                      <pre>{{ query.state$ | async | json }}</pre>\n                    }\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Raw state</p>\n                    <p><i> The query state unaffected by entity stores</i></p>\n\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showRawResponse() }\"\n                        (click)=\"toggleShowRawResponse()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showRawResponse()) {\n                      <pre>{{ query.rawState | json }}</pre>\n                    }\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Query config</p>\n\n                    <div>\n                      <button\n                        [ngClass]=\"{ 'et-qd-chip-secondary': !showQueryConfig() }\"\n                        (click)=\"toggleShowQueryConfig()\"\n                        class=\"et-qd-chip et-qd-chip-bordered\"\n                      >\n                        Toggle\n                      </button>\n                    </div>\n                    @if (showQueryConfig()) {\n                      <pre>{{ stringifiedQueryConfig() | json }}</pre>\n                    }\n                  </div>\n\n                  @if (!!query._queryConfig.entity) {\n                    <div class=\"et-qd-list-item\">\n                      <p>Entity store value</p>\n\n                      <div>\n                        <button\n                          [ngClass]=\"{ 'et-qd-chip-secondary': !showEntityStoreValue() }\"\n                          (click)=\"toggleShowEntityStoreValue()\"\n                          class=\"et-qd-chip et-qd-chip-bordered\"\n                        >\n                          Toggle\n                        </button>\n                      </div>\n                      @if (showEntityStoreValue()) {\n                        <pre>{{ selectedQueryEntityStoreValue$ | async | json }}</pre>\n                      }\n                    </div>\n                  }\n                </div>\n              }\n            </div>\n          </div>\n        } @else if (viewMode() === 'authProvider') {\n          <div class=\"et-qd-auth-provider__viewer\">\n            @if (authProviderDetails(); as details) {\n              <div class=\"et-qd-list\">\n                <div class=\"et-qd-list-item\">\n                  <p>Type</p>\n                  <pre>{{ details.type }}</pre>\n                </div>\n                <div class=\"et-qd-list-item\">\n                  <p>Header value</p>\n                  <pre>{{ details.header() | json }}</pre>\n                </div>\n                <div class=\"et-qd-list-item\">\n                  <p>Config</p>\n                  <pre>{{ details.config | json }}</pre>\n                </div>\n\n                @if (details.type === 'BearerAuthProvider') {\n                  <div class=\"et-qd-list-item\">\n                    <p>Tokens</p>\n                    <pre>{{ details.provider.tokens$ | async | json }}</pre>\n                  </div>\n\n                  <div class=\"et-qd-list-item\">\n                    <p>Should refresh on unauthorized response</p>\n                    <pre>{{ details.provider.shouldRefreshOnUnauthorizedResponse }}</pre>\n                  </div>\n\n                  <ng-container\n                    *etQuery=\"\n                      details.provider.currentRefreshQuery$ | async as response;\n                      loading as loading;\n                      error as error;\n                      query as query\n                    \"\n                  >\n                    <div class=\"et-qd-list-item\">\n                      <p>Refresh query response</p>\n\n                      <div>\n                        <button (click)=\"details.provider._refreshQuery()\" class=\"et-qd-chip et-qd-chip-bordered\">\n                          Refresh\n                        </button>\n                      </div>\n                      <pre>{{ response | json }}</pre>\n                    </div>\n                    <div class=\"et-qd-list-item\">\n                      <p>Refresh query loading</p>\n                      <pre>{{ loading }}</pre>\n                    </div>\n                    <div class=\"et-qd-list-item\">\n                      <p>Refresh query error</p>\n                      <pre>{{ error ?? 'null' }}</pre>\n                    </div>\n                    <div class=\"et-qd-list-item\">\n                      <p>State</p>\n                      <pre>{{ query?.state$ | async | json }}</pre>\n                    </div>\n                  </ng-container>\n                }\n              </div>\n            } @else {\n              <p>No auth provider set</p>\n            }\n          </div>\n        }\n      </div>\n    }\n  </div>\n}\n", styles: [":host{position:fixed;top:0;z-index:1000000;font-size:14px;color:#fff}.et-query-devtools-container{position:fixed;inset:0;background-color:#25292e;z-index:10000;overflow:auto;font-family:monospace;display:grid;grid-template-rows:auto auto auto minmax(0,1fr)}.et-query-devtools-container.et-query-devtools-container--transparent{opacity:.25;pointer-events:none}.et-query-devtools-container.et-query-devtools-container--transparent .et-query-devtools-translucent-btn{pointer-events:all}.et-query-devtools-container.et-query-devtools-container--snap-left{inset-inline-start:0;inset-block-start:0;inset-block-end:0;width:50%;border-right:1px solid rgb(37,41,46)}.et-query-devtools-container.et-query-devtools-container--snap-right{inset-inline-start:unset;inset-inline-end:0;inset-block-start:0;inset-block-end:0;width:50%;border-left:1px solid rgb(37,41,46)}.et-query-devtools-container.et-query-devtools-container--snap-top{inset-inline-start:0;inset-block-start:0;inset-inline-end:0;height:50%;border-bottom:1px solid rgb(37,41,46)}.et-query-devtools-container.et-query-devtools-container--snap-bottom{inset-inline-start:0;inset-block-start:unset;inset-block-end:0;inset-inline-end:0;height:50%;border-top:1px solid rgb(37,41,46)}button.et-query-devtools-open-btn{position:fixed;inset-inline-end:20px;inset-block-end:0;z-index:9999;font-family:monospace;border-radius:3px 3px 0 0;line-height:14px;font-size:12px}.et-qd-header{background-color:#00ffa1;padding:12px;display:grid;grid-template-columns:1fr auto auto;gap:12px;align-items:center}.et-qd-header__title{color:#25292e;margin:0;font-size:22px}.et-qd-header__select{display:grid;background-color:#25292e;border-radius:10px;overflow:hidden}.et-qd-header__select select{width:250px;color:#fff;padding:3px 10px 2px;border:none;background-color:#25292e;font-family:monospace}.et-qd-header__select label{padding:3px 10px;color:#25292e;font-size:12px;font-weight:700;color:#fff;border-bottom:1px solid gray}.et-qd-sub-header{background-color:#00b371;padding:12px;display:flex;gap:12px;flex-wrap:wrap}.et-qd-sub-header__divider{width:1px;background-color:#25292e}.et-qd-btn{background-color:#00ffa1;color:#25292e;border:none;padding:12px;cursor:pointer;font-size:14px;font-weight:700;text-align:center;text-decoration:none;display:inline-block;width:100%;transition:all .3s ease-in-out;font-family:monospace;border-radius:10px}.et-qd-btn:hover{background-color:#00cc81}.et-qd-btn.et-qd-btn-secondary{background-color:#25292e;color:#00ffa1}.et-qd-btn.et-qd-btn-secondary:hover{background-color:#3c424a}.et-qd-chip{background-color:#00ffa1;color:#25292e;border:none;padding:4px 9px;cursor:pointer;font-size:12px;font-weight:700;text-align:center;text-decoration:none;display:inline-block;transition:all .3s ease-in-out;font-family:monospace;border-radius:10px}.et-qd-chip:hover{background-color:#00cc81}.et-qd-chip.et-qd-chip-secondary{background-color:#25292e;color:#00ffa1}.et-qd-chip.et-qd-chip-secondary:hover{background-color:#3c424a}.et-qd-chip.et-qd-chip-bordered{border:1px solid rgb(0,255,161)}.et-qd-translucent-clickable{pointer-events:all}.et-qd-client{border-bottom:1px solid #3c424a;padding:12px}.et-qd-client__title{margin:0;font-size:14px;color:#fff;font-weight:700}.et-qd-client__actions{display:flex;gap:12px;margin-top:12px}.et-qd-queries{padding:12px;display:grid;grid-template-rows:auto auto minmax(0,1fr)}.et-qd-queries__actions{display:flex;gap:12px;margin-top:12px;margin-bottom:16px}.et-qd-queries__title{margin:0;font-size:14px;color:#fff;font-weight:700}.et-qd-queries__divider{width:1px;background-color:#3c424a}.et-qd-queries__browser{display:grid;grid-template-columns:1fr minmax(0,3fr);margin-left:-12px;margin-right:-12px;border-top:1px solid #3c424a;margin-bottom:-12px}.et-qd-queries__browser-list{border-right:1px solid #3c424a;list-style:none;padding:0;margin:0;display:grid;grid-auto-flow:row;grid-auto-rows:55px;overflow-y:auto;overflow-x:hidden}.et-qd-queries__browser-list li{margin:0}.et-qd-queries__browser-list li button{all:unset;font-family:monospace;box-sizing:border-box;width:100%;border:none;border-bottom:1px solid #3c424a;background-color:#25292e;color:#fff;text-align:left;padding:12px;height:100%;transition:all .3s ease-in-out;cursor:pointer;display:grid;grid-template-columns:auto minmax(0,1fr);gap:2px;display:block}.et-qd-queries__browser-list li button span{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.et-qd-queries__browser-list li button span:first-of-type{font-weight:700}.et-qd-queries__browser-list li button:hover,.et-qd-queries__browser-list li button.et-qd-query--active{background-color:#30363c}.et-qd-queries__browser-detail{padding:12px;overflow-y:auto;overflow-x:hidden}.et-qd-queries__browser-detail__title{margin:0;font-size:14px;color:#fff;font-weight:700}.et-qd-auth-provider__viewer{border-top:1px solid #3c424a;margin-left:-12px;margin-right:-12px;margin-bottom:-12px;padding:12px;overflow-y:auto;overflow-x:hidden}.et-qd-list{display:grid;gap:12px}.et-qd-list-item{display:grid}.et-qd-list-item p{font-weight:700;margin:0;padding-bottom:8px}.et-qd-list-item p+p{margin-top:-8px}.et-qd-list-item div+pre{margin-top:8px}.et-qd-list-item pre{margin:0;padding:4px;background-color:#0e1012;border-radius:4px;max-height:450px;overflow:auto}\n"] }]
+        }], ctorParameters: () => [] });
+
+class EntityStoreError extends Error {
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = 'EntityStoreError';
+    }
+}
+function flatten(arr) {
+    return arr.reduce((acc, val) => acc.concat(val), []);
+}
+class EntityStore {
+    constructor(_config) {
+        this._config = _config;
+        /**
+         * @internal
+         */
+        this._dictionary = new Map();
+        /**
+         * @internal
+         */
+        this._change$ = new Subject();
+    }
+    select(keyOrKeys) {
+        if (Array.isArray(keyOrKeys)) {
+            const _keys = this._normalizeKeys(keyOrKeys);
+            return this._selectMany(_keys);
+        }
+        return this._select(keyOrKeys);
+    }
+    /**
+     * **Note:** Prefer `select` over `selectWhere` when possible.
+     */
+    selectWhere(predicate) {
+        return this._change$.pipe(startWith(null), debounceTime(0), map(() => Array.from(this._dictionary.values()).filter(predicate)), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    set(keyOrKeys, valueOrValues) {
+        const _keys = this._normalizeKeys(keyOrKeys);
+        if (Array.isArray(_keys)) {
+            if (!Array.isArray(valueOrValues)) {
+                throw new EntityStoreError('When setting multiple keys, values must be an array', {
+                    keyOrValues: _keys,
+                    valueOrValues,
+                });
+            }
+            const _values = (Array.isArray(valueOrValues[0]) ? flatten(valueOrValues) : valueOrValues);
+            for (let i = 0; i < _keys.length; i++) {
+                const k = _keys[i];
+                const v = _values[i];
+                if (k === undefined || v === undefined)
+                    continue;
+                this._set(k, v);
+            }
+        }
+        else {
+            this._set(_keys, valueOrValues);
+        }
+        this._change$.next(_keys);
+    }
+    remove(keyOrKeys) {
+        const _keys = this._normalizeKeys(keyOrKeys);
+        if (Array.isArray(_keys)) {
+            for (const key of _keys) {
+                this._remove(key);
+            }
+        }
+        else {
+            this._remove(_keys);
+        }
+        this._change$.next(_keys);
+    }
+    logState() {
+        console.log('EntityStore:', this._config.name, {
+            dictionary: this._dictionary,
+        });
+    }
+    _select(key) {
+        if (this._config.logActions) {
+            console.log('EntityStore: select', this._config.name, key);
+        }
+        return this._change$.pipe(startWith(null), filter((v) => {
+            if (v === null) {
+                return true;
+            }
+            if (Array.isArray(v)) {
+                return v.includes(key);
+            }
+            return v === key;
+        }), map(() => this._dictionary.get(key) ?? null));
+    }
+    _selectMany(keys) {
+        if (this._config.logActions) {
+            console.log('EntityStore: selectMany', this._config.name, keys);
+        }
+        return this._change$.pipe(startWith(null), filter((v) => {
+            if (v === null) {
+                return true;
+            }
+            if (Array.isArray(v)) {
+                return keys.some((key) => v.includes(key));
+            }
+            return keys.includes(v);
+        }), map(() => keys.map((key) => this._dictionary.get(key)).filter((value) => value !== undefined)));
+    }
+    _set(key, value) {
+        if (this._config.logActions) {
+            console.log('EntityStore: set', this._config.name, key, value);
+        }
+        this._dictionary.set(key, value);
+    }
+    _remove(key) {
+        if (this._config.logActions) {
+            console.log('EntityStore: remove', this._config.name, key);
+        }
+        this._dictionary.delete(key);
+    }
+    _normalizeKeys(keys) {
+        if (Array.isArray(keys)) {
+            if (Array.isArray(keys[0])) {
+                return flatten(keys);
+            }
+            return keys;
+        }
+        return keys;
+    }
+}
+
+function mapToPaginated(response) {
+    return map((items) => ({ ...response, items }));
+}
+// FIXME: This breaks if SubStoreType is an array
+/**
+ * Use an other store to represent a property of the current entity.
+ */
+const insertFrom = (store, { for: key, id }) => switchMap((value) => {
+    if (!value)
+        return of(null);
+    const ids = id(value);
+    if (Array.isArray(ids)) {
+        return store.select(ids).pipe(map((data) => ({ ...value, [key]: data })));
+    }
+    else {
+        return store.select(ids).pipe(map((data) => ({ ...value, [key]: data })));
+    }
+});
+/**
+ * Remove entities from a store based on a where function.
+ */
+const removeFrom = (store, { where, id }) => {
+    store
+        .selectWhere(where)
+        .pipe(tap((entities) => store.remove(entities.map(id))), take(1))
+        .subscribe();
+};
+
+const transformToString = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return null;
+};
+const transformToStringArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToString).filter(Boolean);
+    }
+    else if (typeof value === 'string') {
+        return [transformToString(value)];
+    }
+    return null;
+};
+const transformToNumber = (value) => {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return Number(value);
+    }
+    return null;
+};
+const transformToNumberArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToNumber).filter((item) => item !== null);
+    }
+    else if (typeof value === 'number') {
+        return [value];
+    }
+    return null;
+};
+const transformToBoolean = (value) => {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value === 'true' || value === '1';
+    }
+    return null;
+};
+const transformToBooleanArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToBoolean).filter((item) => item !== null);
+    }
+    else if (typeof value === 'string' || typeof value === 'boolean') {
+        return [transformToBoolean(value)];
+    }
+    return null;
+};
+const transformToDate = (value) => {
+    if (value instanceof Date) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const date = new Date(value);
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+        return date;
+    }
+    return null;
+};
+const transformToDateArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToDate).filter((item) => item !== null);
+    }
+    else if (typeof value === 'string' || value instanceof Date) {
+        return [transformToDate(value)];
+    }
+    return null;
+};
+const transformToSort = (value) => {
+    if (typeof value === 'string') {
+        const [active, direction] = value.split(':');
+        if (!active) {
+            return null;
+        }
+        return {
+            active,
+            direction: direction,
+        };
+    }
+    return null;
+};
+const transformToSortQueryParam = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object' && 'active' in value && 'direction' in value) {
+        const valAsSort = value;
+        return valAsSort.direction ? `${valAsSort.active}:${valAsSort.direction}` : null;
+    }
+    return null;
+};
+
+const ET_ARR_PREFIX = 'ET_ARR__';
+class QueryField {
+    get control() {
+        return this.data.control;
+    }
+    constructor(data) {
+        this.data = data;
+    }
+}
+const IGNORED_FILTER_COUNT_FIELDS = ['page', 'skip', 'take', 'limit', 'sort', 'sortBy', 'sortOrder', 'query', 'search'];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class QueryForm {
+    get _formValue() {
+        return this.form.getRawValue();
+    }
+    get _form() {
+        return this.form;
+    }
+    get controls() {
+        return this.form.controls;
+    }
+    get value() {
+        return this._changes$.value.currentValue;
+    }
+    get defaultFormValue() {
+        return Object.entries(this._defaultValues).reduce((acc, [key]) => {
+            acc[key] = this._getDefaultValue(key);
+            return acc;
+        }, {});
+    }
+    // with prefix eg. page should become ${prefix}-page
+    constructor(_fields, _options) {
+        this._fields = _fields;
+        this._options = _options;
+        this._destroy$ = createDestroy();
+        this._unobserveTrigger$ = new Subject();
+        this._router = inject(Router);
+        this._activatedRoute = inject(ActivatedRoute);
+        this._defaultValues = this._extractDefaultValues();
+        this._routerStateService = inject(RouterStateService);
+        this._zone = inject(NgZone);
+        this._didValueChanges$ = new Subject();
+        this._isObserving = false;
+        this._skipNextResets = false;
+        /**
+         * The angular form group that contains all the fields.
+         *
+         * **Do not** use any of the following methods on this form group:
+         * - `setValue`: Use `QueryForm.setValue` instead.
+         * - `patchValue`: Use `QueryForm.patchValue` instead.
+         * - `valueChanges`: Use `QueryForm.changes$` instead.
+         * - `value`: Use `QueryForm.value` instead.
+         * - `controls`: Use `QueryForm.controls` instead.
+         */
+        this.form = this._setupFormGroup();
+        this._lastFormValue$ = new BehaviorSubject(null);
+        this._currentFormValue$ = new BehaviorSubject(this._formValue);
+        this._changes$ = new BehaviorSubject({
+            previousValue: null,
+            currentValue: this.form.getRawValue(),
+        });
+        this.changes$ = this._changes$.asObservable();
+        this.currentValue$ = this._changes$.pipe(map(({ currentValue }) => currentValue));
+        this.previousValue$ = this._changes$.pipe(map(({ previousValue }) => previousValue));
+        this.changes = toSignal(this.changes$);
+        this.currentValue = toSignal(this.currentValue$);
+        this.previousValue = toSignal(this.previousValue$);
+        /**
+         * The number of active filters.
+         *
+         * Excludes the following fields by default:
+         * - `page`
+         * - `skip`
+         * - `take`
+         * - `limit`
+         * - `sort`
+         * - `sortBy`
+         * - `sortOrder`
+         * - `query`
+         * - `search`
+         */
+        this.activeFilterCount$ = this.changes$.pipe(map(({ currentValue }) => Object.entries(currentValue)
+            .map(([key, value]) => {
+            if (IGNORED_FILTER_COUNT_FIELDS.includes(key) || this._fields[key]?.data.skipInFilterCount) {
+                return true;
+            }
+            return this._isDefaultValue(key, value);
+        })
+            .filter((v) => v === false).length));
+        assertInInjectionContext(QueryForm);
+    }
+    observe(options) {
+        if (this._isObserving) {
+            if (isDevMode()) {
+                console.warn('QueryForm.observe() was called multiple times. This is not supported.');
+            }
+            return this;
+        }
+        this._isObserving = true;
+        if (options?.syncOnNavigation !== false) {
+            const didChanges = this.setFormValueFromUrlQueryParams({
+                queryParams: this._routerStateService.queryParams,
+            });
+            if (didChanges) {
+                this._handleFormChange(true);
+            }
+        }
+        merge(...Object.values(this._fields).map((field) => field.control.valueChanges), this._didValueChanges$)
+            .pipe(debounceTime(0), tap(() => {
+            this._handleFormChange();
+        }), takeUntil(this._destroy$), takeUntil(this._unobserveTrigger$))
+            .subscribe();
+        let changedFieldsInLastResetLoop = [];
+        let currentUniqueChangedFields = [];
+        this._currentFormValue$
+            .pipe(map((currentValue) => {
+            return {
+                previousValue: clone(this._lastFormValue$.value),
+                currentValue: clone(currentValue),
+            };
+        }), tap(({ currentValue, previousValue }) => {
+            if (options?.writeToQueryParams !== false) {
+                this._syncViaUrlQueryParams(currentValue, options?.replaceUrl);
+            }
+            const didResetValues = this._skipNextResets
+                ? false
+                : this._handleQueryFormResets(previousValue ?? null, currentValue);
+            this._skipNextResets = false;
+            const changedFields = Object.keys(currentValue).filter((key) => !equal(previousValue?.[key], currentValue[key]));
+            if (changedFieldsInLastResetLoop.length) {
+                changedFields.push(...changedFieldsInLastResetLoop);
+                changedFieldsInLastResetLoop = [];
+            }
+            if (didResetValues) {
+                this._didValueChanges$.next(true);
+                changedFieldsInLastResetLoop = changedFields;
+            }
+            currentUniqueChangedFields = [...new Set(changedFields)];
+        }), switchMap(({ currentValue, previousValue }) => {
+            if (changedFieldsInLastResetLoop.length)
+                return of(null).pipe(map(() => ({ currentValue, previousValue })));
+            const debounceValues = currentUniqueChangedFields.map((key) => {
+                const field = this._fields[key];
+                if (!field)
+                    return null;
+                if (field.data.disableDebounceIfFalsy === true && !currentValue[key]) {
+                    return null;
+                }
+                return field.data.debounce ?? null;
+            });
+            currentUniqueChangedFields = [];
+            if (debounceValues.some((v) => v === null) || !debounceValues.length) {
+                return of(null).pipe(map(() => ({ currentValue, previousValue })));
+            }
+            const shortestDebounceTime = Math.min(...debounceValues.filter((v) => v !== null));
+            return timer(shortestDebounceTime).pipe(map(() => ({ currentValue, previousValue })));
+        }), tap(({ currentValue, previousValue }) => {
+            if (changedFieldsInLastResetLoop.length)
+                return;
+            this._changes$.next({
+                previousValue: previousValue ?? null,
+                currentValue: currentValue,
+            });
+        }), takeUntil(this._destroy$), takeUntil(this._unobserveTrigger$))
+            .subscribe();
+        if (options?.syncOnNavigation !== false) {
+            this._routerStateService.queryParamChanges$
+                .pipe(takeUntil(this._destroy$), takeUntil(this._unobserveTrigger$), tap((changes) => {
+                const didValueChanges = this.setFormValueFromUrlQueryParams({ queryParams: changes });
+                if (didValueChanges) {
+                    this._didValueChanges$.next(true);
+                }
+            }))
+                .subscribe();
+        }
+        return this;
+    }
+    _handleQueryFormResets(previousValue, currentValue) {
+        let didResetValues = false;
+        for (const formFieldKey in this._fields) {
+            const field = this._fields[formFieldKey];
+            if (!field)
+                continue;
+            const resets = field.data.isResetBy;
+            if (!resets)
+                continue;
+            const resetConditionKeys = Array.isArray(resets) ? resets : [resets];
+            for (const resetConditionKey of resetConditionKeys) {
+                if (!(resetConditionKey in this._fields)) {
+                    if (isDevMode()) {
+                        console.warn(`The field "${resetConditionKey}" is not defined in the QueryForm. Is it a typo?`, this);
+                    }
+                    continue;
+                }
+                if (previousValue &&
+                    currentValue &&
+                    !equal(previousValue[resetConditionKey], currentValue[resetConditionKey])) {
+                    const defaultValueForKeyToReset = this._getDefaultValue(formFieldKey);
+                    const currentValueForKeyToReset = currentValue[formFieldKey];
+                    if (equal(defaultValueForKeyToReset, currentValueForKeyToReset)) {
+                        continue;
+                    }
+                    this.form.controls[formFieldKey].setValue(defaultValueForKeyToReset);
+                    didResetValues = true;
+                    break;
+                }
+            }
+        }
+        return didResetValues;
+    }
+    unobserve() {
+        this._unobserveTrigger$.next(true);
+    }
+    setFormValueFromUrlQueryParams(options) {
+        let didValueChanges = false;
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = options.queryParams[this._transformKeyToQueryParam(key)];
+            const valueDoesNotExist = value === undefined;
+            if (valueDoesNotExist)
+                continue;
+            const valueGotRemoved = value === ET_PROPERTY_REMOVED;
+            if (valueGotRemoved) {
+                field.control.setValue(this._getDefaultValue(key), { emitEvent: false });
+                didValueChanges = true;
+                continue;
+            }
+            let deserializedValue = value;
+            if (field.data.queryParamToValueTransformFn) {
+                deserializedValue = field.data.queryParamToValueTransformFn(value);
+            }
+            else if (typeof this._getDefaultValue(key) === 'number' || !isNaN(Number(value))) {
+                deserializedValue = transformToNumber(value);
+            }
+            else if (typeof this._getDefaultValue(key) === 'boolean' || value === 'true' || value === 'false') {
+                deserializedValue = transformToBoolean(value);
+            }
+            const valueIsEqualToCurrent = equal(deserializedValue, field.control.value);
+            if (valueIsEqualToCurrent)
+                continue;
+            field.control.setValue(deserializedValue, { emitEvent: false });
+            didValueChanges = true;
+        }
+        return didValueChanges;
+    }
+    setValue(value, options) {
+        this._form._setValue(value, options);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    patchValue(value, options) {
+        this._form._patchValue(value, options);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    resetFieldToDefault(key, options) {
+        const defaultValue = this._getDefaultValue(key);
+        this.form.controls[key].setValue(defaultValue);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    resetFieldsToDefault(keys, options) {
+        const defaults = keys.reduce((acc, key) => {
+            acc[key] = this._getDefaultValue(key);
+            return acc;
+        }, {});
+        this.patchValue(defaults);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    resetAllFieldsToDefault(options) {
+        const keys = Object.keys(this._fields);
+        if (options?.skipFields) {
+            for (const key of options.skipFields) {
+                const index = keys.indexOf(key);
+                if (index !== -1) {
+                    keys.splice(index, 1);
+                }
+            }
+        }
+        this.resetFieldsToDefault(keys, options);
+    }
+    _getDefaultValue(key) {
+        const val = this._defaultValues[key];
+        if (typeof val === 'string' && val.startsWith(ET_ARR_PREFIX)) {
+            return JSON.parse(val.slice(ET_ARR_PREFIX.length));
+        }
+        return val ?? null;
+    }
+    _transformKeyToQueryParam(key) {
+        if (!this._options?.queryParamPrefix)
+            return key;
+        const prefix = typeof this._options?.queryParamPrefix === 'string'
+            ? this._options.queryParamPrefix
+            : this._options.queryParamPrefix();
+        return `${prefix}-${key}`;
+    }
+    _isDefaultValue(key, value) {
+        const normalizedValue = Array.isArray(value) ? `${ET_ARR_PREFIX}${JSON.stringify(value)}` : value;
+        return this._getDefaultValue(key) === normalizedValue;
+    }
+    _setupFormGroup() {
+        const group = new FormGroup({});
+        for (const [key, field] of Object.entries(this._fields)) {
+            group.addControl(key, field.control);
+        }
+        group._patchValue = group.patchValue;
+        group._setValue = group.setValue;
+        group.patchValue = this.patchValue.bind(this);
+        group.setValue = this.setValue.bind(this);
+        return group;
+    }
+    _extractDefaultValues() {
+        const defaultValues = {};
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = field.data.defaultValue !== undefined ? field.data.defaultValue : field.control.value;
+            if (Array.isArray(value)) {
+                defaultValues[key] = `${ET_ARR_PREFIX}${JSON.stringify(value)}`;
+            }
+            else {
+                defaultValues[key] = value;
+            }
+        }
+        return defaultValues;
+    }
+    _syncViaUrlQueryParams(values, replaceUrl) {
+        const queryParams = { ...clone(this._activatedRoute.snapshot.queryParams) };
+        for (const [key, value] of Object.entries(values)) {
+            const queryParamKey = this._transformKeyToQueryParam(key);
+            const field = this._fields[key];
+            if (!field) {
+                continue;
+            }
+            const isDefault = this._isDefaultValue(key, value);
+            const writeDefaultToUrl = field.data.appendDefaultValueToUrl === true;
+            const writeToUrl = field.data.appendToUrl !== false;
+            if (!writeToUrl || (isDefault && !writeDefaultToUrl)) {
+                queryParams[queryParamKey] = undefined;
+            }
+            else {
+                queryParams[queryParamKey] = field.data.valueToQueryParamTransformFn
+                    ? field.data.valueToQueryParamTransformFn?.(value)
+                    : value;
+            }
+        }
+        this._zone.run(() => {
+            this._router.navigate([], {
+                queryParams,
+                replaceUrl,
+                queryParamsHandling: 'merge',
+            });
+        });
+    }
+    _handleFormChange(forceOverwrite = false) {
+        const currentVal = clone(this._currentFormValue$.value);
+        const newVal = clone(this._formValue);
+        if (equal(currentVal, newVal)) {
+            return;
+        }
+        if (forceOverwrite) {
+            this._lastFormValue$.next(newVal);
+        }
+        else {
+            this._lastFormValue$.next(currentVal);
+        }
+        this._currentFormValue$.next(newVal);
+    }
+}
+
+// Burst cache
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BasicAuthProvider, BearerAuthProvider, CustomHeaderAuthProvider, EntityStore, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, QUERY_CLIENT_DEVTOOLS_TOKEN, Query, QueryClient, QueryCreator, QueryDevtoolsComponent, QueryDirective, QueryError, QueryField, QueryForm, QueryShortNamePipe, QueryStore, addQueryContainerHandling, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, createInfinityQueryConfig, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, decryptBearer, deepFreeze, def, detectContentTypeHeader, extractExpiresInSeconds, extractQuery, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getResponseUrl, gql, hasHeader, ignoreAutoRefresh, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mergeHeaders, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, pathParamsMissingInRouteFunctionError, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetPageOnError, serializeBody, shouldCacheQuery, shouldRetryRequest, skipPaginationPageParamCalculator, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray };
+//# sourceMappingURL=ethlete-query.mjs.map