@ethlete/query 6.0.0-next.20 → 6.0.0-next.22

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @ethlete/query
 
+## 6.0.0-next.22
+
+### Minor Changes
+
+- [#3040](https://github.com/ethlete-io/ethdk/pull/3040) [`dcd8585`](https://github.com/ethlete-io/ethdk/commit/dcd8585423c4d0a66d968016a6e88b03c87b168a) Thanks [@github-actions](https://github.com/apps/github-actions)! - Error normalization: reduce an HTML error page (a proxy's `502`, a maintenance page) to its heading and message text instead of using the raw markup as the message. Exposes `isHtmlErrorPayload`, `htmlErrorPayload` and `extractHtmlErrorMessage`.
+
+### Patch Changes
+
+- [#3040](https://github.com/ethlete-io/ethdk/pull/3040) [`bc8aca7`](https://github.com/ethlete-io/ethdk/commit/bc8aca76900a47a3faed4ad2be2ce2ab7b70b27d) Thanks [@github-actions](https://github.com/apps/github-actions)! - Filter overlay: new `provideFilterOverlay` / `injectFilterOverlay` — a filter panel that drafts the page's query
+  form, reports how many results the draft would return on its submit button, and applies on submit or discards on
+  dismiss. Replaces cdk's `FilterOverlayService`, rebuilt on signal forms and the current query client.
+
+## 6.0.0-next.21
+
+### Patch Changes
+
+- [#3038](https://github.com/ethlete-io/ethdk/pull/3038) [`0be9397`](https://github.com/ethlete-io/ethdk/commit/0be939765c6074a518c5c05a7110513f1e3e8ef0) Thanks [@TomTomB](https://github.com/TomTomB)! - Fix `ET301` on every legacy interop mutation. `LegacyQuery.execute()` translates v2's single `skipCache` into
+  `allowCache: options.skipCache !== true` for **every** method, so any `legacyPost*` / `legacyPut*` /
+  `legacyPatch*` / `legacyDelete*` executed without an explicit `skipCache: true` reached the repository with
+  `allowCache: true` and threw "This request is uncacheable, but allowCache is set to true".
+
+  `allowCache` is never read on the uncacheable path — there is no cache entry to reuse — so the throw was purely a
+  guard against a mistake in hand-written code. It stays for that, and gains a
+  `silenceUncacheableAllowCacheError` opt-out on `QueryConfig`, which `createLegacyQueryCreator` sets alongside the
+  `silenceMissingWithArgsFeatureError` it already passed. The cache-key guard is unaffected.
+
+  Note that dropping `allowCache: true` in the interop instead would have silently made every legacy `GET` refetch,
+  since an absent `allowCache` means "do not reuse the entry" rather than "use the default".
+
 ## 6.0.0-next.20
 
 ### Minor Changes

package/fesm2022/ethlete-query.mjs

@@ -1014,6 +1014,7 @@ const queryExecute = (options) => {
         previousKey: executeState.previousKey(),
         runQueryOptions,
         isSecure,
+        silenceUncacheableAllowCacheError: queryConfig.silenceUncacheableAllowCacheError,
     });
     executeState.previousKey.set(key);
     state.lastTimeExecutedAt.set(Date.now());
@@ -1678,6 +1679,149 @@ const buildQueryCacheKey = (route, args) => {
     return hash.toString();
 };
 
+/**
+ * An error body can be an HTML page instead of JSON: a proxy's 502, a load balancer's maintenance page, a
+ * platform's "service temporarily unavailable". The markup is never worth showing, but the sentence inside it
+ * usually is — this file pulls that sentence out.
+ *
+ * Parsing is done with string matching rather than `DOMParser` on purpose: it must work during SSR, and the
+ * markup must never reach a DOM. What comes back is plain text, so a template can bind it as text like any
+ * other error message.
+ */
+/** A full document, however sloppily written. */
+const HTML_DOCUMENT_PATTERN = /<!doctype\s+html|<html[\s>]|<head[\s>]|<body[\s>]/i;
+/** A fragment — matched only as a balanced pair, so a message that merely mentions `<p>` is not markup. */
+const HTML_ELEMENT_PATTERN = /<(h[1-6]|p|div|title|pre)\b[^>]*>[\s\S]*<\/\1>/i;
+/** Carries no readable text, and `<style>` in particular would otherwise flood the fallback. */
+const HTML_NOISE_PATTERN = /<(script|style|noscript|svg|iframe|template)\b[^>]*>[\s\S]*?<\/\1>/gi;
+const HTML_COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
+const HTML_TAG_PATTERN = /<[^>]*>/g;
+const HTML_ENTITY_PATTERN = /&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]*);/gi;
+const HTML_BODY_PATTERN = /<body\b[^>]*>([\s\S]*?)<\/body>/i;
+const HTML_HEADING_PATTERN = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/i;
+const HTML_TITLE_PATTERN = /<title\b[^>]*>([\s\S]*?)<\/title>/i;
+const HTML_PARAGRAPH_PATTERN = /<p\b[^>]*>([\s\S]*?)<\/p>/gi;
+/**
+ * The entities an error page actually uses. A complete table would be kilobytes for no gain — anything missing
+ * is left as written, which is still readable.
+ */
+const HTML_ENTITIES = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+    ensp: ' ',
+    emsp: ' ',
+    thinsp: ' ',
+    shy: '',
+    ndash: '–',
+    mdash: '—',
+    hellip: '…',
+    lsquo: '‘',
+    rsquo: '’',
+    ldquo: '“',
+    rdquo: '”',
+    laquo: '«',
+    raquo: '»',
+    bull: '•',
+    middot: '·',
+    deg: '°',
+    copy: '©',
+    reg: '®',
+    trade: '™',
+    euro: '€',
+    pound: '£',
+    auml: 'ä',
+    ouml: 'ö',
+    uuml: 'ü',
+    Auml: 'Ä',
+    Ouml: 'Ö',
+    Uuml: 'Ü',
+    szlig: 'ß',
+};
+/** Long enough for a real explanation, short enough that a dumped stack trace can't become the message. */
+const MAX_MESSAGE_LENGTH = 300;
+const MAX_CODE_POINT = 0x10ffff;
+const decodeHtmlEntities = (value) => value.replace(HTML_ENTITY_PATTERN, (match, entity) => {
+    if (entity.startsWith('#')) {
+        const isHex = entity[1] === 'x' || entity[1] === 'X';
+        const codePoint = Number.parseInt(isHex ? entity.slice(2) : entity.slice(1), isHex ? 16 : 10);
+        // `String.fromCodePoint` throws on anything out of range, and a malformed page is exactly where that shows up.
+        return Number.isInteger(codePoint) && codePoint > 0 && codePoint <= MAX_CODE_POINT
+            ? String.fromCodePoint(codePoint)
+            : match;
+    }
+    return HTML_ENTITIES[entity] ?? HTML_ENTITIES[entity.toLowerCase()] ?? match;
+});
+/**
+ * Tags are dropped before entities are decoded, so an escaped `&lt;script&gt;` in the page's text can never
+ * turn back into markup on the way out.
+ */
+const toPlainText = (html) => decodeHtmlEntities(html.replace(HTML_TAG_PATTERN, ' ')).replace(/\s+/g, ' ').trim();
+const truncate = (value) => value.length <= MAX_MESSAGE_LENGTH ? value : `${value.slice(0, MAX_MESSAGE_LENGTH - 1).trimEnd()}…`;
+const matchText = (html, pattern, group) => {
+    const text = pattern.exec(html)?.[group];
+    return text ? toPlainText(text) || null : null;
+};
+const paragraphTexts = (html) => {
+    const texts = [];
+    for (const match of html.matchAll(HTML_PARAGRAPH_PATTERN)) {
+        const text = toPlainText(match[1] ?? '');
+        if (text)
+            texts.push(text);
+    }
+    return texts;
+};
+/**
+ * Whether a value is an HTML error page rather than a message meant to be read as-is.
+ *
+ * Deliberately strict: a document marker, or a balanced element pair. A message containing a stray `<` or a
+ * lone `<br>` stays a message.
+ */
+const isHtmlErrorPayload = (value) => typeof value === 'string' && (HTML_DOCUMENT_PATTERN.test(value) || HTML_ELEMENT_PATTERN.test(value));
+/**
+ * The HTML of an error body, or `null` when the body isn't an error page.
+ *
+ * Two shapes carry one: the raw string body of any failed response, and the `{ error, text }` wrapper
+ * Angular's XHR backend produces when a `200` response fails to parse as JSON — which is how a proxy handing
+ * back an HTML page with a success status arrives.
+ */
+const htmlErrorPayload = (body) => {
+    if (isHtmlErrorPayload(body))
+        return body;
+    if (typeof body === 'object' && !!body && 'text' in body && isHtmlErrorPayload(body.text)) {
+        return body.text;
+    }
+    return null;
+};
+/**
+ * The readable message inside an HTML error page, or `null` when it has none.
+ *
+ * Prefers what a page puts its message in: the first heading (or the `<title>` when there is no heading),
+ * followed by the first paragraph that says something new. Falls back to the page's flattened text, so an
+ * unusually structured page still yields something. The result is always plain text, and always short enough
+ * to sit in a toast.
+ *
+ * @example
+ * extractHtmlErrorMessage('<h1>Service Unavailable</h1><p>The server is restarting.</p>');
+ * // 'Service Unavailable: The server is restarting.'
+ */
+const extractHtmlErrorMessage = (html) => {
+    const document = html.replace(HTML_COMMENT_PATTERN, ' ').replace(HTML_NOISE_PATTERN, ' ');
+    const body = HTML_BODY_PATTERN.exec(document)?.[1] ?? document;
+    const headline = matchText(body, HTML_HEADING_PATTERN, 2) ?? matchText(document, HTML_TITLE_PATTERN, 1);
+    const detail = paragraphTexts(body).find((text) => text !== headline) ?? null;
+    if (headline && detail) {
+        // A headline that already ends in punctuation is a sentence, not a label.
+        const separator = /[.!?:]$/.test(headline) ? ' ' : ': ';
+        return truncate(`${headline}${separator}${detail}`);
+    }
+    const message = headline ?? detail ?? toPlainText(body);
+    return message ? truncate(message) : null;
+};
+
 const shouldRetryRequest = (options) => {
     const normalizedOptions = options instanceof HttpErrorResponse ? { retryCount: 0, error: options } : options;
     const { retryCount, error } = normalizedOptions;
@@ -1761,7 +1905,17 @@ const createQueryErrorResponse = (error) => {
     const retryState = shouldRetryRequest(err);
     const detail = err.error;
     const errorList = [];
-    if (isClassValidatorError(detail)) {
+    const html = htmlErrorPayload(detail);
+    if (html) {
+        // An HTML error page (a proxy's 502, a maintenance page) is never shown as-is: keep the sentence inside it
+        // and drop the markup. A page with no readable text leaves the list empty, which falls back to the
+        // HttpErrorResponse's own message below — still better than a wall of tags.
+        const message = extractHtmlErrorMessage(html);
+        if (message) {
+            errorList.push({ message });
+        }
+    }
+    else if (isClassValidatorError(detail)) {
         for (const error of detail.message) {
             errorList.push({ message: error });
         }
@@ -3401,7 +3555,11 @@ class LegacyQuery {
         this.newQuery.subtle.destroy();
     }
     execute(options = {}) {
-        untracked(() => this.newQuery.execute({ args: this._arguments, options: { allowCache: options.skipCache !== true } }));
+        untracked(() => 
+        // v2 had a single `skipCache` for every method, so this cannot tell whether the underlying request is
+        // cacheable. The creator is built with `silenceUncacheableAllowCacheError`, which makes `allowCache` inert
+        // on a mutation instead of throwing ET301.
+        this.newQuery.execute({ args: this._arguments, options: { allowCache: options.skipCache !== true } }));
         return this;
     }
     abort() {
@@ -3612,6 +3770,8 @@ class LegacyQueryCreator {
                         onlyManualExecution: true,
                         injector,
                         silenceMissingWithArgsFeatureError: true,
+                        // `LegacyQuery.execute()` forwards v2's `skipCache` as `allowCache` for every method, cacheable or not.
+                        silenceUncacheableAllowCacheError: true,
                     });
                     const legacyQuery = new LegacyQuery(newQuery, queryArgs, this.options.entity);
                     if (args?.config?.destroyOnResponse) {
@@ -5723,8 +5883,11 @@ const createQueryRepository = (config) => {
             : shouldCacheQuery(options.method) || creatorOptions?.subtle?.useQueryRepositoryCache === true;
         if (!shouldCache && options.key)
             throw uncacheableRequestHasCacheKeyParam(options.key);
-        if (!shouldCache && runQueryOptions?.allowCache)
+        // `allowCache` is never read on the uncacheable path below — there is no cache entry to reuse — so this throw
+        // is purely a guard against a mistake in hand-written code. The legacy interop opts out of it.
+        if (!shouldCache && runQueryOptions?.allowCache && !options.silenceUncacheableAllowCacheError) {
             throw uncacheableRequestHasAllowCacheParam();
+        }
         const route = buildRoute({
             base: config.baseUrl,
             route: options.route,
@@ -8915,5 +9078,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DateArrayQueryField, DateQueryField, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryForm, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, removeFrom, request, resetExecuteState, resetPageOnError, searchQueryField, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRoute, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DateArrayQueryField, DateQueryField, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryForm, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, removeFrom, request, resetExecuteState, resetPageOnError, searchQueryField, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRoute, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
 //# sourceMappingURL=ethlete-query.mjs.map