@ethlete/query 0.1.0-next.0

package/fesm2020/ethlete-query.mjs

@@ -0,0 +1,1412 @@
+import { Subject, timer, filter, takeWhile, BehaviorSubject, interval, takeUntil, tap, switchMap, of, fromEvent, startWith, concat, take, debounceTime, combineLatest, map, distinctUntilChanged } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Directive, Input, InjectionToken, inject, ChangeDetectorRef, ViewContainerRef, TemplateRef, ErrorHandler, ElementRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Router, ActivatedRoute } from '@angular/router';
+
+class CustomHeaderAuthProvider {
+    constructor(_config) {
+        this._config = _config;
+        this.queryClient = null;
+    }
+    get header() {
+        return { [this._config.name]: this._config.value };
+    }
+    cleanUp() {
+        // noop
+    }
+}
+
+class BasicAuthProvider {
+    constructor(_config) {
+        this._config = _config;
+        this.queryClient = null;
+    }
+    get header() {
+        return { Authorization: `Basic ${this._basicAuthString}` };
+    }
+    get _basicAuthString() {
+        return btoa(`${this._config.username}:${this._config.password}`);
+    }
+    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 isRequestError = (error) => error instanceof Object && 'code' in error && 'message' in error;
+const isAbortRequestError = (error) => isRequestError(error) && error.code === -1;
+const buildRoute = (options) => {
+    if (options.base.endsWith('/')) {
+        throw invalidBaseRouteError(options.base);
+    }
+    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);
+        if (queryString) {
+            route = route ? `${route}?${queryString}` : `/?${queryString}`;
+        }
+    }
+    return `${options.base}${route ?? ''}`;
+};
+const buildQueryString = (params) => {
+    const validParams = filterInvalidParams(params);
+    const queryString = Object.keys(validParams)
+        .map((key) => Array.isArray(validParams[key])
+        ? buildQueryArrayString(key, validParams[key])
+        : `${key}=${encodeURIComponent(validParams[key])}`)
+        .join('&');
+    return queryString || null;
+};
+const buildQueryArrayString = (key, array) => {
+    const uriBrackets = encodeURIComponent('[]');
+    return array
+        .slice()
+        .map((item) => `${key}${uriBrackets}=${encodeURIComponent(item)}`)
+        .join('&');
+};
+const isFetchResponse = (response) => typeof response === 'object' &&
+    response !== null &&
+    'status' in response &&
+    'statusText' in response &&
+    'json' in response &&
+    typeof response['json'] === 'function';
+const filterInvalidParams = (params) => {
+    const filteredParams = Object.entries(params)
+        .map(([key, value]) => {
+        if (!Array.isArray(value)) {
+            return [key, value];
+        }
+        return [key, value.filter((v) => isParamValid(v))];
+    })
+        .filter(([, value]) => isParamValid(value))
+        .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    return filteredParams;
+};
+const isParamValid = (primitive) => {
+    if (primitive === undefined || primitive === null || primitive === '') {
+        return false;
+    }
+    if (typeof primitive === 'string' && primitive.trim() === '') {
+        return false;
+    }
+    if (typeof primitive === 'number' && isNaN(primitive)) {
+        return false;
+    }
+    return true;
+};
+const extractExpiresInSeconds = (headers) => {
+    const cacheControl = headers.get('cache-control');
+    const age = headers.get('age');
+    const expires = headers.get('expires');
+    // In seconds
+    let expiresIn = null;
+    let maxAge = null;
+    if (cacheControl?.includes('no-cache')) {
+        return null;
+    }
+    if (cacheControl?.includes('max-age')) {
+        maxAge = parseInt(cacheControl.split('max-age=')[1]);
+    }
+    else if (cacheControl?.includes('s-maxage')) {
+        maxAge = parseInt(cacheControl.split('s-maxage=')[1]);
+    }
+    if (maxAge && age) {
+        const ageSeconds = parseInt(age);
+        expiresIn = maxAge - ageSeconds;
+    }
+    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 buildRequestError = async (error) => {
+    if (error instanceof DOMException && error.code === error.ABORT_ERR) {
+        const err = {
+            code: -1,
+            message: 'Request aborted',
+            detail: null,
+            raw: error,
+        };
+        return err;
+    }
+    if (error instanceof SyntaxError) {
+        const err = {
+            code: -3,
+            message: 'Syntax error',
+            detail: null,
+            raw: error,
+        };
+        return err;
+    }
+    if (error instanceof Error) {
+        const err = {
+            code: -2,
+            message: `${error.name}: ${error.message}`,
+            detail: null,
+            raw: error,
+        };
+        return err;
+    }
+    if (isFetchResponse(error)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let detail;
+        try {
+            detail = await error.text();
+        }
+        catch (err) {
+            detail = null;
+        }
+        const err = {
+            code: error.status,
+            message: error.statusText,
+            detail,
+            raw: error,
+        };
+        return err;
+    }
+    const err = {
+        code: 0,
+        message: 'Unknown error',
+        detail: null,
+        raw: error,
+    };
+    return err;
+};
+const buildBody = (body) => {
+    if (body === undefined || body === null) {
+        return null;
+    }
+    if (typeof body === 'string') {
+        return body;
+    }
+    if (typeof body === 'object') {
+        return JSON.stringify(body);
+    }
+    if (body instanceof FormData) {
+        return body;
+    }
+    throw invalidBodyError(body);
+};
+const transformMethod = (method) => {
+    if (method === 'GQL_QUERY' || method === 'GQL_MUTATE') {
+        return 'POST';
+    }
+    return method;
+};
+const guessContentType = (body) => {
+    if (body === null || body === undefined) {
+        return null;
+    }
+    if (typeof body === 'string') {
+        return 'text/plain';
+    }
+    if (body instanceof FormData) {
+        return 'multipart/form-data';
+    }
+    if (typeof body === 'object') {
+        return 'application/json';
+    }
+    return null;
+};
+
+const request = async (options) => {
+    try {
+        const response = await fetch(options.route, options.init);
+        if (!response.ok) {
+            throw response;
+        }
+        const data = (await response.json());
+        const expiresInSeconds = options.cacheAdapter
+            ? options.cacheAdapter(response.headers)
+            : extractExpiresInSeconds(response.headers);
+        const expiresInTimestamp = buildTimestampFromSeconds(expiresInSeconds);
+        return { data, expiresInTimestamp };
+    }
+    catch (error) {
+        throw await buildRequestError(error);
+    }
+};
+
+const isBasicAuthProvider = (authProvider) => authProvider instanceof BasicAuthProvider;
+const isBearerAuthProvider = (authProvider) => authProvider instanceof BearerAuthProvider;
+const isCustomHeaderAuthProvider = (authProvider) => authProvider instanceof CustomHeaderAuthProvider;
+const decryptBearer = (token) => {
+    try {
+        const base64Url = token.split('.')[1];
+        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split('')
+            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch (error) {
+        console.error(`Invalid bearer token: ${token}`, error);
+        return null;
+    }
+};
+
+class BearerAuthProvider {
+    constructor(_config) {
+        this._config = _config;
+        this._refreshToken = null;
+        this._refreshTimerSubscription = null;
+        this.queryClient = null;
+        this.onRefreshInitiation$ = new Subject();
+        this.onRefreshSuccess$ = new Subject();
+        this.onRefreshFailure$ = new Subject();
+        this._token = _config.token;
+        this._refreshToken = _config.refreshConfig?.token ?? null;
+        if (this._config.refreshConfig) {
+            this._setupRefresh(this._config.refreshConfig);
+        }
+    }
+    get header() {
+        return { Authorization: `Bearer ${this._token}` };
+    }
+    cleanUp() {
+        this._refreshTimerSubscription?.unsubscribe();
+        this._refreshTimerSubscription = null;
+    }
+    _setupRefresh(config) {
+        const bearer = decryptBearer(this._token);
+        if (!bearer) {
+            return;
+        }
+        const expiresInPropertyName = config.expiresInPropertyName || 'exp';
+        const expiresIn = bearer[expiresInPropertyName];
+        const fiveMinutes = 5 * 60 * 1000;
+        if (expiresIn === undefined) {
+            throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);
+        }
+        const remainingTime = new Date(expiresIn * 1000).getTime() - fiveMinutes - new Date().getTime();
+        const strategy = config.strategy ?? "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */;
+        switch (strategy) {
+            case "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */:
+                this._refreshTimerSubscription = timer(remainingTime).subscribe(() => this._refresh(config));
+                break;
+        }
+    }
+    async _refresh(config) {
+        if (!this._refreshToken) {
+            throw new Error('No refresh token found');
+        }
+        if (!this.queryClient) {
+            throw new Error('Query client instance is null');
+        }
+        const { method, route, bodyAdapter, responseAdapter } = config;
+        const fullRoute = buildRoute({
+            base: this.queryClient.config.baseRoute,
+            route,
+        });
+        const body = bodyAdapter ? bodyAdapter(this._refreshToken) : { refreshToken: this._refreshToken };
+        this.onRefreshInitiation$.next();
+        try {
+            const result = await request({
+                route: fullRoute,
+                init: { body: buildBody(body), method },
+            });
+            const tokens = responseAdapter ? responseAdapter(result.data) : result.data;
+            if (!tokens.token) {
+                throw new Error('Token not found in response');
+            }
+            if (!tokens.refreshToken) {
+                throw new Error('Refresh token not found in response');
+            }
+            this._token = tokens.token;
+            this._refreshToken = tokens.refreshToken;
+            this.onRefreshSuccess$.next(tokens);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.onRefreshFailure$.next(await buildRequestError(error));
+            }
+            else {
+                this.onRefreshFailure$.next(error);
+            }
+        }
+    }
+}
+
+const getOpName = /(query|mutation) ?([\w\d-_]+)? ?\(.*?\)? \{/;
+const transformGql = (str) => {
+    str = Array.isArray(str) ? str.join('') : str;
+    const name = getOpName.exec(str);
+    return function (variables) {
+        const data = { query: str };
+        if (variables)
+            data['variables'] = JSON.stringify(variables);
+        if (name && name.length) {
+            const operationName = name[2];
+            if (operationName)
+                data['operationName'] = name[2];
+        }
+        return JSON.stringify(data);
+    };
+};
+const gql = (strings, ...values) => {
+    const str = strings.reduce((acc, cur, i) => {
+        return acc + cur + (values[i] || '');
+    }, '');
+    return str;
+};
+
+const deepFreeze = (object) => {
+    // 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;
+
+function filterSuccess() {
+    return function (source) {
+        return source.pipe(filter((value) => isQueryStateSuccess(value)));
+    };
+}
+function filterFailure() {
+    return function (source) {
+        return source.pipe(filter((value) => isQueryStateFailure(value)));
+    };
+}
+function takeUntilResponse() {
+    return function (source) {
+        return source.pipe(takeWhile((value) => isQueryStateLoading(value), true));
+    };
+}
+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 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;
+};
+
+class Query {
+    constructor(_client, _queryConfig, _route, _args) {
+        this._client = _client;
+        this._queryConfig = _queryConfig;
+        this._route = _route;
+        this._args = _args;
+        this._currentId = 0;
+        this._abortController = new AbortController();
+        this._pollingSubscription = null;
+        this._state$ = new BehaviorSubject({
+            type: "PREPARED" /* QueryStateType.Prepared */,
+            meta: { id: this._currentId },
+        });
+    }
+    get _nextId() {
+        return this._currentId++;
+    }
+    get state$() {
+        return this._state$.asObservable();
+    }
+    get state() {
+        return this._state$.value;
+    }
+    get isExpired() {
+        if (!isQueryStateSuccess(this.state)) {
+            return false;
+        }
+        const ts = this.state.meta.expiresAt;
+        if (!ts) {
+            return true;
+        }
+        return ts < Date.now();
+    }
+    clone() {
+        return this._client.fetch(this._queryConfig);
+    }
+    execute(options) {
+        if (!this.isExpired && !options?.skipCache && isQueryStateSuccess(this.state)) {
+            return this;
+        }
+        if (this._queryConfig.secure && !this._client.authProvider) {
+            throw new Error('Cannot execute secure query without auth provider');
+        }
+        const id = this._nextId;
+        if (isQueryStateLoading(this._state$.value)) {
+            this.abort();
+        }
+        const meta = deepFreeze({ id });
+        this._state$.next({
+            type: "LOADING" /* QueryStateType.Loading */,
+            meta,
+        });
+        let body = null;
+        let contentType = null;
+        if (isGqlQueryConfig(this._queryConfig)) {
+            const queryTemplate = this._queryConfig.query;
+            const query = transformGql(queryTemplate);
+            contentType = 'application/json';
+            body = query(this._args?.variables);
+        }
+        else {
+            body = buildBody(this._args?.body);
+            contentType = guessContentType(body);
+        }
+        let authHeader = null;
+        if (this._queryConfig.secure) {
+            const header = this._client.authProvider?.header;
+            if (header) {
+                authHeader = header;
+            }
+        }
+        else if (this._client.authProvider?.header) {
+            if (this._queryConfig.secure === undefined || this._queryConfig.secure) {
+                authHeader = this._client.authProvider.header;
+            }
+        }
+        let headers = mergeHeaders(authHeader, this._args?.headers);
+        if (contentType && !headers?.['Content-Type'] && !headers?.['content-type']) {
+            if (headers) {
+                headers['Content-Type'] = contentType;
+            }
+            else {
+                headers = {
+                    'Content-Type': contentType,
+                };
+            }
+        }
+        request({
+            route: this._route,
+            init: {
+                method: transformMethod(this._queryConfig.method),
+                signal: this._abortController.signal,
+                body,
+                headers: headers || undefined,
+            },
+            cacheAdapter: this._client.config.request?.cacheAdapter,
+        })
+            .then((response) => {
+            const isResponseObject = typeof response === 'object';
+            const isGql = isGqlQueryConfig(this._queryConfig);
+            let responseData = null;
+            if (isGql && isResponseObject && 'data' in response.data) {
+                responseData = response.data['data'];
+            }
+            else {
+                responseData = response.data;
+            }
+            const transformedResponse = this._queryConfig.responseTransformer
+                ? this._queryConfig.responseTransformer(responseData)
+                : responseData;
+            this._state$.next({
+                type: "SUCCESS" /* QueryStateType.Success */,
+                response: deepFreeze(transformedResponse),
+                rawResponse: deepFreeze(responseData),
+                meta: deepFreeze({ ...meta, expiresAt: response.expiresInTimestamp }),
+            });
+        })
+            .catch((error) => this._handleExecuteError(error, meta));
+        return this;
+    }
+    abort() {
+        this._abortController.abort();
+        this._abortController = new AbortController();
+        return this;
+    }
+    poll(config) {
+        if (this._pollingSubscription) {
+            return this;
+        }
+        this._pollingSubscription = interval(config.interval)
+            .pipe(takeUntil(config.takeUntil))
+            .subscribe(() => this.execute({ skipCache: true }));
+        return this;
+    }
+    stopPolling() {
+        this._pollingSubscription?.unsubscribe();
+        this._pollingSubscription = null;
+        return this;
+    }
+    _handleExecuteError(error, meta) {
+        if (isAbortRequestError(error)) {
+            this._state$.next({
+                type: "CANCELLED" /* QueryStateType.Cancelled */,
+                meta,
+            });
+        }
+        else if (isRequestError(error)) {
+            this._state$.next({
+                type: "FAILURE" /* QueryStateType.Failure */,
+                error,
+                meta,
+            });
+        }
+        else {
+            throw error;
+        }
+    }
+}
+
+class QueryDirective {
+    constructor(_mainTemplateRef, _viewContainerRef, _errorHandler, _cdr) {
+        this._mainTemplateRef = _mainTemplateRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._errorHandler = _errorHandler;
+        this._cdr = _cdr;
+        this._isMainViewCreated = false;
+        this._subscription = null;
+        this._viewContext = {
+            $implicit: null,
+            query: null,
+            raw: null,
+            loading: false,
+            error: 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;
+        if (!this.query) {
+            return;
+        }
+        const sub = this.query.state$.pipe(tap((state) => this._updateView(state))).subscribe();
+        this._subscription = sub;
+    }
+    _updateView(state) {
+        if (isQueryStateLoading(state)) {
+            this._viewContext.loading = true;
+        }
+        else {
+            this._viewContext.loading = false;
+        }
+        if (isQueryStateSuccess(state)) {
+            this._viewContext.query = state.response;
+            this._viewContext.$implicit = state.response;
+            this._viewContext.raw = state.rawResponse;
+        }
+        else if (!this.cache) {
+            this._viewContext.query = null;
+            this._viewContext.$implicit = null;
+            this._viewContext.raw = 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);
+        }
+    }
+}
+QueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: QueryDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.ErrorHandler }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+QueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.8", type: QueryDirective, isStandalone: true, selector: "[query]", inputs: { query: "query", cache: ["queryCache", "cache"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: QueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[query]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.ErrorHandler }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { query: [{
+                type: Input
+            }], cache: [{
+                type: Input,
+                args: ['queryCache']
+            }] } });
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class InfinityQuery {
+    constructor(_config) {
+        this._config = _config;
+        this._currentPage$ = new BehaviorSubject(null);
+        this._currentCalculatedPage$ = new BehaviorSubject(null);
+        this._totalPages$ = new BehaviorSubject(null);
+        this._itemsPerPage$ = new BehaviorSubject(this._config.limitParam?.value ?? 10);
+        this._currentQuery$ = new BehaviorSubject(null);
+        this._data$ = new BehaviorSubject([]);
+        this._subscriptions = [];
+    }
+    get currentPage$() {
+        return this._currentPage$.asObservable();
+    }
+    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 currentQuery$() {
+        return this._currentQuery$.asObservable();
+    }
+    get currentQuery() {
+        return this._currentQuery$.getValue();
+    }
+    get data$() {
+        return this._data$.asObservable();
+    }
+    get data() {
+        return this._data$.getValue();
+    }
+    nextPage() {
+        const newPage = (this._currentPage$.value ?? 0) + 1;
+        const calculatedPage = this._config?.pageParam?.valueCalculator?.({
+            page: newPage,
+            totalPages: this.totalPages,
+            itemsPerPage: this.itemsPerPage,
+        }) ?? newPage;
+        const args = this._prepareArgs(this._config, calculatedPage);
+        const query = this._config.queryCreator.prepare(args).execute();
+        this._handleNewQuery(query);
+        this._currentPage$.next(newPage);
+        this._currentCalculatedPage$.next(calculatedPage);
+        this._currentQuery$.next(query);
+    }
+    reset(newConfig) {
+        this._destroy();
+        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._currentQuery$.next(null);
+        this._data$.next([]);
+    }
+    _destroy() {
+        this._subscriptions.forEach((sub) => sub.unsubscribe());
+        this._subscriptions = [];
+    }
+    _handleNewQuery(query) {
+        const stateChangesSub = query.state$.pipe(takeUntilResponse(), filterSuccess()).subscribe({
+            next: (state) => {
+                let newData = this._config?.response.valueExtractor(state.response);
+                if (this._config.response.reverse) {
+                    newData = [...newData].reverse();
+                }
+                if (this._config.response.appendItemsTo === 'start') {
+                    newData = [...newData, ...this.data];
+                }
+                else {
+                    newData = [...this.data, ...newData];
+                }
+                this._data$.next(newData);
+                const totalPages = this._config.response.totalPagesExtractor?.({
+                    response: state.response,
+                    itemsPerPage: this.itemsPerPage,
+                }) ??
+                    state.response?.totalPages ??
+                    null;
+                this._totalPages$.next(totalPages);
+            },
+            complete: () => {
+                this._subscriptions = this._subscriptions.filter((sub) => sub !== stateChangesSub);
+            },
+        });
+        this._subscriptions.push(stateChangesSub);
+    }
+    _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 {
+    constructor() {
+        this._viewContext = {
+            $implicit: null,
+            infinityQuery: null,
+            loading: false,
+            error: null,
+            isFirstLoad: false,
+            canLoadMore: false,
+            currentPage: null,
+            currentCalculatedPage: null,
+            totalPages: null,
+            itemsPerPage: null,
+        };
+        this._infinityQueryInstance = null;
+        this._destroy$ = new Subject();
+        this._cdr = inject(ChangeDetectorRef);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._mainTemplateRef = inject((TemplateRef));
+        this._errorHandler = inject(ErrorHandler);
+        this._isMainViewCreated = false;
+    }
+    get infinityQuery() {
+        return this._infinityQuery;
+    }
+    set infinityQuery(v) {
+        this._infinityQuery = v;
+        this._infinityQueryInstance = this._setupInfinityQuery(v);
+        this._loadNextPage();
+    }
+    get context() {
+        return this._viewContext;
+    }
+    get instance() {
+        return this._infinityQueryInstance;
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    ngOnInit() {
+        this._renderMainView();
+    }
+    ngOnDestroy() {
+        this._destroy$.next(true);
+        this._destroy$.unsubscribe();
+        this.instance?._destroy();
+    }
+    _setupInfinityQuery(config) {
+        const instance = new InfinityQuery(config);
+        instance.currentQuery$
+            .pipe(switchMap((q) => q?.state$ ?? of(null)), tap((state) => {
+            this._viewContext.currentPage = instance.currentPage;
+            this._viewContext.totalPages = instance.totalPages;
+            this._viewContext.itemsPerPage = instance.itemsPerPage;
+            this._viewContext.canLoadMore =
+                (instance.totalPages && instance.currentPage && instance.totalPages > instance.currentPage) || false;
+            this._viewContext.currentCalculatedPage = instance.currentCalculatedPage;
+            if (isQueryStateLoading(state)) {
+                this._viewContext.loading = true;
+                this._viewContext.error = null;
+                this._viewContext.isFirstLoad = this.context.infinityQuery === 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;
+            }
+            else {
+                this._viewContext.loading = false;
+                this._viewContext.error = null;
+                this._viewContext.infinityQuery = 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._cdr.markForCheck();
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        instance.data$
+            .pipe(tap((data) => {
+            this._viewContext.infinityQuery = this._viewContext.$implicit = data;
+            this._cdr.markForCheck();
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        return instance;
+    }
+    _loadNextPage() {
+        if (!this._infinityQueryInstance) {
+            return;
+        }
+        this._infinityQueryInstance.nextPage();
+    }
+    _renderMainView() {
+        if (!this._isMainViewCreated) {
+            this._isMainViewCreated = true;
+            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);
+        }
+    }
+}
+InfinityQueryDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: InfinityQueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+InfinityQueryDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.8", type: InfinityQueryDirective, isStandalone: true, selector: "[infinityQuery]", inputs: { infinityQuery: "infinityQuery" }, providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: InfinityQueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[infinityQuery]',
+                    standalone: true,
+                    providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }],
+                }]
+        }], propDecorators: { infinityQuery: [{
+                type: Input
+            }] } });
+
+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.hasAttribute('infinityQueryTrigger');
+        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.isIntersecting && !this._infinityQuery.context.loading) {
+                this._infinityQuery._loadNextPage();
+            }
+        }, {
+            root: this.scrollContainerSelector ? document.querySelector(this.scrollContainerSelector) : null,
+            rootMargin: '0px',
+            threshold: 1.0,
+        });
+        this._observer.observe(this._elementRef.nativeElement);
+    }
+}
+InfinityQueryTriggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: InfinityQueryTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+InfinityQueryTriggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.8", type: InfinityQueryTriggerDirective, isStandalone: true, selector: "[infinityQueryTrigger], infinity-query-trigger", inputs: { scrollContainerSelector: "scrollContainerSelector" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.8", ngImport: i0, type: InfinityQueryTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[infinityQueryTrigger], infinity-query-trigger',
+                    standalone: true,
+                }]
+        }], propDecorators: { scrollContainerSelector: [{
+                type: Input
+            }] } });
+
+class QueryStore {
+    constructor(_config) {
+        this._config = _config;
+        this._store = new Map();
+        this._garbageCollector = null;
+    }
+    add(id, query) {
+        this._store.set(id, query);
+        this._initGarbageCollector();
+        this._logState(id, query, 'SET');
+    }
+    get(id) {
+        return this._store.get(id) ?? null;
+    }
+    remove(id) {
+        this._store.delete(id);
+        this._logState(id, null, 'REMOVE');
+    }
+    _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;
+        }
+    }
+    _runGarbageCollector() {
+        this._logGarbageCollector('Collecting...');
+        this._store.forEach((item, key) => {
+            if (item.isExpired) {
+                this.remove(key);
+            }
+        });
+        this._logGarbageCollector('Collection done');
+        if (!this._store.size) {
+            this._stopGarbageCollector();
+            this._logGarbageCollector('Stop');
+        }
+    }
+    _logGarbageCollector(action) {
+        if (!this._config?.enableGarbageCollectorLogging)
+            return;
+        console.log(`%cGC: ${action}`, 'color: yellow; font-weight: bold');
+    }
+}
+
+const shouldCacheQuery = (method) => {
+    return method === 'GET' || method === 'OPTIONS' || method === 'HEAD' || method === 'GQL_QUERY';
+};
+const buildGqlCacheKey = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+config, args) => {
+    const { query } = config;
+    const variables = args?.variables || {};
+    const queryWithoutNewLinesAndWhitespace = query.replace(/\s/g, '');
+    const queryFirst50Chars = queryWithoutNewLinesAndWhitespace.slice(0, 50);
+    const queryMiddle25Chars = queryWithoutNewLinesAndWhitespace.slice(queryWithoutNewLinesAndWhitespace.length / 2 - 25, queryWithoutNewLinesAndWhitespace.length / 2 + 25);
+    const queryLast50Chars = queryWithoutNewLinesAndWhitespace.slice(-50);
+    const vars = JSON.stringify(variables);
+    return `${queryFirst50Chars}...${queryMiddle25Chars}...${queryLast50Chars}...${vars}`;
+};
+
+class QueryClient {
+    constructor(_clientConfig) {
+        this._clientConfig = _clientConfig;
+        this._authProvider = 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) => {
+            const prepare = (args) => {
+                const route = buildRoute({
+                    base: this._clientConfig.baseRoute,
+                    route: queryConfig.route,
+                    pathParams: args?.pathParams,
+                    queryParams: args?.queryParams,
+                });
+                const cacheKey = isGqlQueryConfig(queryConfig) ? buildGqlCacheKey(queryConfig, args) : route;
+                if (shouldCacheQuery(queryConfig.method)) {
+                    const existingQuery = this._store.get(cacheKey);
+                    if (existingQuery) {
+                        return existingQuery;
+                    }
+                }
+                const query = new Query(this, queryConfig, route, args);
+                if (shouldCacheQuery(queryConfig.method)) {
+                    this._store.add(cacheKey, query);
+                }
+                return query;
+            };
+            const behaviorSubject = (initialValue = null) => new BehaviorSubject(initialValue);
+            return {
+                prepare,
+                behaviorSubject,
+            };
+        };
+        this.setAuthProvider = (authProvider) => {
+            if (this._authProvider) {
+                throw new Error('The auth provider is already set. Please call clearAuthProvider() first.');
+            }
+            this._authProvider = authProvider;
+            authProvider.queryClient = this;
+        };
+        this.clearAuthProvider = () => {
+            this._authProvider?.cleanUp();
+            this._authProvider = null;
+        };
+        this._store = new QueryStore({
+            enableChangeLogging: _clientConfig.logging?.queryStateChanges,
+            enableGarbageCollectorLogging: _clientConfig.logging?.queryStateGarbageCollector,
+        });
+    }
+    get config() {
+        return this._clientConfig;
+    }
+    get authProvider() {
+        return this._authProvider;
+    }
+}
+
+class QueryField {
+    constructor(data) {
+        this.data = data;
+        this.changes$ = this._setupChangesObservable();
+        this._currentDebounceTimeout = null;
+    }
+    get control() {
+        return this.data.control;
+    }
+    setValue(value) {
+        if (this._currentDebounceTimeout !== null) {
+            clearTimeout(this._currentDebounceTimeout);
+        }
+        if (this.data.debounce) {
+            this._currentDebounceTimeout = window.setTimeout(() => {
+                this.control.setValue(value);
+            }, this.data.debounce);
+        }
+        else {
+            this.control.setValue(value);
+        }
+    }
+    _setupChangesObservable() {
+        const obs = this.control.valueChanges.pipe(startWith(this.control.value));
+        if (!this.data.debounce) {
+            return obs;
+        }
+        // The initial value should get emitted immediately
+        // concat switches to the debounced observable after the first observable is completed
+        return concat(obs.pipe(take(1)), this.control.valueChanges.pipe(debounceTime(this.data.debounce)));
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class QueryForm {
+    constructor(_fields) {
+        this._fields = _fields;
+        this._router = inject(Router, { optional: true });
+        this._activatedRoute = inject(ActivatedRoute, { optional: true });
+        this._defaultValues = this._extractDefaultValues();
+        this.form = this._setupFormGroup();
+    }
+    observe(options) {
+        return combineLatest(Object.values(this._fields).map((field) => field.changes$)).pipe(map(() => this.form.getRawValue()), distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), tap((values) => {
+            if (options?.syncViaUrlQueryParams !== false) {
+                this._syncViaUrlQueryParams(values);
+            }
+        }));
+    }
+    setFormValueFromUrlQueryParams() {
+        if (!this._activatedRoute) {
+            throw new Error('Cannot set form value from url query params without ActivatedRoute');
+        }
+        const queryParams = this._activatedRoute.snapshot.queryParams;
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = queryParams[key];
+            if (value === undefined) {
+                continue;
+            }
+            const deserializedValue = field.data.queryParamTransformFn?.(value) ?? value;
+            field.setValue(deserializedValue);
+        }
+    }
+    updateFormOnUrlQueryParamsChange() {
+        if (!this._activatedRoute) {
+            throw new Error('Cannot update form on url query params change without ActivatedRoute');
+        }
+        return this._activatedRoute.queryParams.pipe(tap(() => this.setFormValueFromUrlQueryParams()));
+    }
+    _getDefaultValue(key) {
+        return this._defaultValues[key] ?? null;
+    }
+    _isDefaultValue(key, value) {
+        const normalizedValue = Array.isArray(value) ? 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);
+        }
+        return group;
+    }
+    _extractDefaultValues() {
+        const defaultValues = {};
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = field.control.value;
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                defaultValues[key] = JSON.stringify(value);
+            }
+            else {
+                defaultValues[key] = value;
+            }
+        }
+        return defaultValues;
+    }
+    _syncViaUrlQueryParams(values) {
+        if (!this._router || !this._activatedRoute) {
+            return;
+        }
+        const queryParams = structuredClone(this._activatedRoute.snapshot.queryParams);
+        for (const [key, value] of Object.entries(values)) {
+            if (this._isDefaultValue(key, value) || this._fields[key].data.appendToUrl === false) {
+                delete queryParams[key];
+            }
+            else {
+                queryParams[key] = value;
+            }
+        }
+        this._router.navigate([], {
+            queryParams,
+        });
+    }
+}
+
+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;
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BasicAuthProvider, BearerAuthProvider, CustomHeaderAuthProvider, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, Query, QueryClient, QueryDirective, QueryError, QueryField, QueryForm, QueryStore, buildBody, buildErrorMessage, buildGqlCacheKey, buildQueryArrayString, buildQueryString, buildRequestError, buildRoute, buildTimestampFromSeconds, createInfinityQueryConfig, decryptBearer, deepFreeze, def, extractExpiresInSeconds, filterFailure, filterInvalidParams, filterSuccess, gql, guessContentType, invalidBaseRouteError, invalidBodyError, invalidRouteError, isAbortRequestError, isBasicAuthProvider, isBearerAuthProvider, isCustomHeaderAuthProvider, isFetchResponse, isGqlQueryConfig, isParamValid, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, mergeHeaders, pathParamsMissingInRouteFunctionError, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, request, shouldCacheQuery, skipPaginationPageParamCalculator, takeUntilResponse, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToString, transformToStringArray };
+//# sourceMappingURL=ethlete-query.mjs.map