@ethlete/query 5.40.1 → 5.41.1

package/lib/experimental/http/query-creator.d.ts

@@ -1,82 +0,0 @@
-import { Injector } from '@angular/core';
-import { HttpRequestResponseType, HttpRequestTransferCacheConfig } from './http-request';
-import { AnyQuery, PathParamsType, Query, QueryArgs } from './query';
-import { QueryClientConfig } from './query-client-config';
-import { QueryFeature } from './query-features';
-export type RouteType<TArgs extends QueryArgs> = PathParamsType<TArgs> extends {
-    [key: string]: unknown;
-} ? (args: TArgs['pathParams']) => RouteString : RouteString;
-export type RouteString = `/${string}`;
-export type CreateQueryCreatorOptions = {
-    /**
-     * If true, the query loading state will include progress information.
-     * This is useful for file uploads and downloads.
-     *
-     * **Warning**: Upload progress events are not supported by browsers when using the fetch API, such as with `provideHttpClient(withFetch())`.
-     * In this case, you should use the older XHR implementation by omitting `withFetch()`. But take into account that XHR is not supported in server-side rendering environments.
-     *
-     * @see https://angular.dev/guide/http/making-requests#receiving-raw-progress-events
-     *
-     * @default false
-     */
-    reportProgress?: boolean;
-    /**
-     * The response type of the query.
-     * @default 'json'
-     */
-    responseType?: HttpRequestResponseType;
-    /**
-     * Whether to include credentials (cookies) in the request or not.
-     * @default false
-     */
-    withCredentials?: boolean;
-    /**
-     * This property accepts either a boolean to enable/disable transferring cache for eligible
-     * requests performed using `HttpClient`, or an object, which allows to configure cache
-     * parameters, such as which headers should be included (no headers are included by default).
-     *
-     * Setting this property will override the options passed to `provideClientHydration()` for this
-     * particular request
-     */
-    transferCache?: HttpRequestTransferCacheConfig;
-};
-export type QueryCreator<TArgs extends QueryArgs> = {
-    (...features: QueryFeature<TArgs>[]): Query<TArgs>;
-    (queryConfig: QueryConfig, ...features: QueryFeature<TArgs>[]): Query<TArgs>;
-};
-export type AnyQueryCreator = QueryCreator<any>;
-export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery> = T extends QueryCreator<infer TArgs> ? TArgs : T extends Query<infer TArgs> ? TArgs : never;
-export type RunQueryCreator<TCreator extends AnyQueryCreator> = ReturnType<TCreator>;
-export type QueryMethod = 'GET' | 'OPTIONS' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'TRACE' | 'CONNECT';
-export type InternalCreateQueryCreatorOptions<TArgs extends QueryArgs> = {
-    /**
-     * The route of the query.
-     * If the query has path params, the route should be a function that takes the path params as an argument.
-     * Otherwise, it should be a string.
-     */
-    route: RouteType<TArgs>;
-    method: QueryMethod;
-    client: QueryClientConfig;
-};
-export type QueryConfig = {
-    /** A custom id to use for this query. Only affects queries that can be cached. */
-    key?: string;
-    /**
-     * If true, the query will not be executed automatically.
-     * Does not affect mutations such as POST, PUT etc. since those are never executed automatically.
-     */
-    onlyManualExecution?: boolean;
-    /**
-     * If true, the query will not throw an error because a "withArgs()" feature is missing.
-     */
-    silenceMissingWithArgsFeatureError?: boolean;
-    /**
-     * A custom injector to use for this query.
-     */
-    injector?: Injector;
-};
-export declare const splitQueryConfig: <TArgs extends QueryArgs>(args: (QueryFeature<TArgs> | QueryConfig)[]) => {
-    features: QueryFeature<TArgs>[];
-    queryConfig: QueryConfig;
-};
-export declare const createQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalCreateQueryCreatorOptions<TArgs>) => QueryCreator<TArgs>;

package/lib/experimental/http/query-dependencies.d.ts

@@ -1,26 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { DestroyRef, EnvironmentInjector, ErrorHandler, ɵEffectScheduler } from '@angular/core';
-import { QueryClient } from './query-client';
-import { QueryClientConfig } from './query-client-config';
-import { QueryConfig } from './query-creator';
-export type SetupQueryDependenciesOptions = {
-    clientConfig: QueryClientConfig;
-    queryConfig: QueryConfig | undefined;
-};
-export type QueryDependencies = {
-    /** The destroy ref of the query. */
-    destroyRef: DestroyRef;
-    /** The destroy ref of the scope the query is in (e.g. a component) */
-    scopeDestroyRef: DestroyRef;
-    /** The query client */
-    client: QueryClient;
-    /** The injector of the query */
-    injector: EnvironmentInjector;
-    /** The effect scheduler */
-    effectScheduler: ɵEffectScheduler;
-    /** The error handler */
-    ngErrorHandler: ErrorHandler;
-    /** The http client */
-    httpClient: HttpClient;
-};
-export declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;

package/lib/experimental/http/query-error-response.d.ts

@@ -1,19 +0,0 @@
-import { HttpErrorResponse, HttpStatusCode } from '@angular/common/http';
-import { ShouldRetryRequestResult } from './query-utils';
-export type QueryErrorResponseList = {
-    isList: true;
-    errors: QueryErrorResponseItem[];
-};
-export type QueryErrorResponseSingle = {
-    isList: false;
-    error: QueryErrorResponseItem;
-};
-export type QueryErrorResponse = {
-    raw: HttpErrorResponse;
-    retryState: ShouldRetryRequestResult;
-    code: HttpStatusCode;
-} & (QueryErrorResponseList | QueryErrorResponseSingle);
-export interface QueryErrorResponseItem {
-    message: string;
-}
-export declare const createQueryErrorResponse: (error: unknown) => QueryErrorResponse;

package/lib/experimental/http/query-errors.d.ts

@@ -1,56 +0,0 @@
-import { RuntimeError } from '@ethlete/core';
-import { QueryFeatureType } from './query-features';
-export declare const enum QueryRuntimeErrorCode {
-    QUERY_FEATURE_USED_MULTIPLE_TIMES = 0,
-    WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION = 100,
-    WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD = 101,
-    WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD = 102,
-    WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY = 103,
-    SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT = 104,
-    COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED = 200,
-    ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 201,
-    DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 202,
-    LOGIN_CALLED_WITHOUT_CONFIG = 203,
-    LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG = 204,
-    REFRESH_TOKEN_CALLED_WITHOUT_CONFIG = 205,
-    SELECT_ROLE_CALLED_WITHOUT_CONFIG = 206,
-    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT = 207,
-    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN = 208,
-    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN = 209,
-    UNABLE_TO_DECRYPT_BEARER_TOKEN = 210,
-    BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211,
-    UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM = 300,
-    UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM = 301,
-    PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES = 400,
-    PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE = 401,
-    PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE = 402,
-    QUERY_STACK_WITH_ARGS_USED = 500,
-    QUERY_STACK_WITH_RESPONSE_UPDATE_USED = 501,
-    QUERY_STACK_TOTAL_QUERIES_AND_EXPECTED_QUERIES_MISMATCH = 502
-}
-export declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES>;
-export declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<QueryRuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION>;
-export declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<QueryRuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD>;
-export declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD>;
-export declare const withAutoRefreshUsedInManualQuery: () => RuntimeError<QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY>;
-export declare const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent: () => RuntimeError<QueryRuntimeErrorCode.SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT>;
-export declare const cookieLoginTriedButCookieDisabled: () => RuntimeError<QueryRuntimeErrorCode.COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED>;
-export declare const enableCookieCalledWithoutCookieConfig: () => RuntimeError<QueryRuntimeErrorCode.ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
-export declare const disableCookieCalledWithoutCookieConfig: () => RuntimeError<QueryRuntimeErrorCode.DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
-export declare const loginCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.LOGIN_CALLED_WITHOUT_CONFIG>;
-export declare const loginWithTokenCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG>;
-export declare const refreshTokenCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.REFRESH_TOKEN_CALLED_WITHOUT_CONFIG>;
-export declare const selectRoleCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.SELECT_ROLE_CALLED_WITHOUT_CONFIG>;
-export declare const defaultResponseTransformerResponseNotObject: (currentType: string) => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT>;
-export declare const defaultResponseTransformerResponseNotContainingAccessToken: () => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN>;
-export declare const defaultResponseTransformerResponseNotContainingRefreshToken: () => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN>;
-export declare const unableToDecryptBearerToken: (token: string) => RuntimeError<QueryRuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN>;
-export declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<QueryRuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER>;
-export declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM>;
-export declare const uncacheableRequestHasAllowCacheParam: () => RuntimeError<QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM>;
-export declare const pagedQueryStackPageBiggerThanTotalPages: (page: number, totalPages: number) => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES>;
-export declare const pagedQueryStackNextPageCalledWithoutPreviousPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE>;
-export declare const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE>;
-export declare const queryStackWithArgsUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_ARGS_USED>;
-export declare const queryStackWithResponseUpdateUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_RESPONSE_UPDATE_USED>;
-export declare const queryStackTotalQueriesAndExpectedQueriesMismatch: (totalQueries: number, expectedQueries: number) => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_TOTAL_QUERIES_AND_EXPECTED_QUERIES_MISMATCH>;

package/lib/experimental/http/query-execute-utils.d.ts

@@ -1,42 +0,0 @@
-import { EffectRef, WritableSignal } from '@angular/core';
-import { QueryArgs, RequestArgs } from './query';
-import { CreateQueryExecuteOptions } from './query-execute';
-export type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
-    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state' | 'deps'>;
-    executeState: QueryExecuteState;
-};
-export declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
-export type QueryExecuteState = {
-    effectRefs: EffectRef[];
-    previousKey: WritableSignal<string | false>;
-};
-export declare const setupQueryExecuteState: () => QueryExecuteState;
-export type RunQueryExecuteOptions = {
-    allowCache?: boolean;
-};
-export type InternalRunQueryExecuteOptions = {
-    /**
-     * If true, the request will be forced to be cached (saved inside the query repository).
-     * Can be used to e.g. cache GQL queries transported via POST
-     *
-     * - `true` means the request will always be cached
-     * - `false` means the request will never be cached
-     * - `undefined` means the request will be cached if the method is GET, OPTIONS or HEAD
-     */
-    useQueryRepositoryCache?: boolean;
-};
-export type QueryExecuteOptions<TArgs extends QueryArgs> = {
-    executeOptions: CreateQueryExecuteOptions<TArgs>;
-    executeState: QueryExecuteState;
-    args: RequestArgs<TArgs> | null;
-    options?: RunQueryExecuteOptions;
-    internalOptions?: InternalRunQueryExecuteOptions;
-    transformResponse?: (response: any) => any;
-    isSecure?: boolean;
-};
-export declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
-export type CleanupPreviousExecuteOptions<TArgs extends QueryArgs> = {
-    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state'>;
-    executeState: QueryExecuteState;
-};
-export declare const cleanupPreviousExecute: <TArgs extends QueryArgs>(options: CleanupPreviousExecuteOptions<TArgs>) => void;

package/lib/experimental/http/query-execute.d.ts

@@ -1,25 +0,0 @@
-import { Signal } from '@angular/core';
-import { QueryArgs, RequestArgs } from './query';
-import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
-import { QueryDependencies } from './query-dependencies';
-import { RunQueryExecuteOptions } from './query-execute-utils';
-import { QueryKeyOrNone } from './query-repository';
-import { QueryState } from './query-state';
-export type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
-    deps: QueryDependencies;
-    state: QueryState<TArgs>;
-    creator?: CreateQueryCreatorOptions;
-    creatorInternals: InternalCreateQueryCreatorOptions<TArgs>;
-    queryConfig: QueryConfig;
-};
-export type QueryExecuteArgs<TArgs extends QueryArgs> = {
-    args?: RequestArgs<TArgs> | null;
-    options?: RunQueryExecuteOptions;
-};
-export type InternalQueryExecute<TArgs extends QueryArgs> = {
-    (executeArgs?: QueryExecuteArgs<TArgs>): void;
-    reset: () => void;
-    currentRepositoryKey: Signal<QueryKeyOrNone>;
-};
-export type QueryExecute<TArgs extends QueryArgs> = (executeArgs?: QueryExecuteArgs<TArgs>) => void;
-export declare const createExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;

package/lib/experimental/http/query-features.d.ts

@@ -1,121 +0,0 @@
-import { HttpEvent } from '@angular/common/http';
-import { Signal } from '@angular/core';
-import { QueryArgs, RequestArgs, ResponseType } from './query';
-import { QueryDependencies } from './query-dependencies';
-import { QueryErrorResponse } from './query-error-response';
-import { InternalQueryExecute } from './query-execute';
-import { QueryState } from './query-state';
-import { ClearQueryArgs, QueryFeatureFlags } from './query-utils';
-export declare const enum QueryFeatureType {
-    WithArgs = "withArgs",
-    WithLogging = "withLogging",
-    WithErrorHandling = "withErrorHandling",
-    WithSuccessHandling = "withSuccessHandling",
-    WithPolling = "withPolling",
-    WithAutoRefresh = "withAutoRefresh",
-    WithResponseUpdate = "withResponseUpdate"
-}
-export type QueryFeatureContext<TArgs extends QueryArgs> = {
-    state: QueryState<TArgs>;
-    execute: InternalQueryExecute<TArgs>;
-    deps: QueryDependencies;
-    flags: QueryFeatureFlags;
-};
-export type QueryFeatureFn<TArgs extends QueryArgs> = (context: QueryFeatureContext<TArgs>) => void;
-export type QueryFeature<TArgs extends QueryArgs> = {
-    type: QueryFeatureType;
-    fn: (context: QueryFeatureContext<TArgs>) => void;
-};
-/**
- * A query feature that allows you to set the arguments of the query.
- * The arguments are read within a computed function, so you can use reactive values.
- *
- * To set the arguments to `null`, return the symbol `CLEAR_QUERY_ARGS`.
- * If you instead return `null`, the arguments won't change.
- *
- * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
- */
-export declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | ClearQueryArgs | null) => QueryFeature<TArgs>;
-export type WithPollingFeatureOptions = {
-    /** The interval in milliseconds at which the query should be executed */
-    interval: number;
-    /**
-     * Whether the query should be executed initially.
-     * By default, the query will be executed after the first interval.
-     * @default false
-     */
-    executeInitially?: boolean;
-};
-/**
- * A query feature that will automatically execute the query at a given interval.
- * The interval will be cleared when the query is destroyed.
- * The interval will be reset when the arguments of the query change.
- *
- * @throws If the query is not eligible for auto execution (e.g. a POST request)
- */
-export declare const withPolling: <TArgs extends QueryArgs>(options: WithPollingFeatureOptions) => QueryFeature<TArgs>;
-export type WithLoggingFeatureOptions<TArgs extends QueryArgs> = {
-    /** A function that will be called with the latest http event */
-    logFn: (v: HttpEvent<ResponseType<TArgs>> | null) => void;
-};
-/** A query feature that can be used to log the latest http event */
-export declare const withLogging: <TArgs extends QueryArgs>(options: WithLoggingFeatureOptions<TArgs>) => QueryFeature<TArgs>;
-export type WithErrorHandlingFeatureOptions = {
-    /** A function that will be called with the latest error */
-    handler: (e: QueryErrorResponse) => void;
-};
-/** A query feature that can be used to handle errors */
-export declare const withErrorHandling: <TArgs extends QueryArgs>(options: WithErrorHandlingFeatureOptions) => QueryFeature<TArgs>;
-type WithSuccessHandlingFeatureOptions<TArgs extends QueryArgs> = {
-    /** A function that will be called with the latest response */
-    handler: (data: NonNullable<ResponseType<TArgs>>) => void;
-};
-/** A query feature that can be used to handle successful responses */
-export declare const withSuccessHandling: <TArgs extends QueryArgs>(options: WithSuccessHandlingFeatureOptions<TArgs>) => QueryFeature<TArgs>;
-export type WithAutoRefreshFeatureOptions = {
-    /** The signals that should trigger a refresh of the query */
-    onSignalChanges: Signal<unknown>[];
-    /** Whether to ignore the `onlyManualExecution` query config flag */
-    ignoreOnlyManualExecution?: boolean;
-};
-/**
- * A query feature that will automatically execute the query when any of the provided signals change
- * @throws If the query is not eligible for auto execution (e.g. a POST request)
- * @throws If the query has the `onlyManualExecution` query config flag set and `ignoreOnlyManualExecution` is not set
- */
-export declare const withAutoRefresh: <TArgs extends QueryArgs>(options: WithAutoRefreshFeatureOptions) => QueryFeature<TArgs>;
-export type WithResponseUpdateFeatureFnData<TArgs extends QueryArgs> = {
-    /** The current response of the query */
-    currentResponse: ResponseType<TArgs> | null;
-};
-export type WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = {
-    /**
-     * A function that will be called with the latest response
-     * If the function returns `null`, the response will not be updated.
-     * Otherwise, the response will be updated with the returned value.
-     * The function will be called in a reactive signal context.
-     * If the query get's executed after the response was updated, the response will be set the the fresh data received from the server.
-     *
-     * This feature is most useful in combination with web sockets where the data received from the socket might be more up-to-date than the data received previously.
-     *
-     * @example
-     * const matchEvents = mySocket.joinRoom('match-events');
-     *
-     * const myMatchQuery = getMatch(
-     *  withArgs(() => ({ matchId: 1 })),
-     *  withResponseUpdate(({ currentResponse }) => {
-     *   const matchEvent = matchEvents();
-     *
-     *   if (!matchEvent) return null;
-     *
-     *   // Do some checks here. This is just a very simple example.
-     *   // To apply partial updates, you can use the spread operator in combination with the current response.
-     *
-     *   return matchEvent;
-     *  })
-     * )
-     */
-    updater: (data: WithResponseUpdateFeatureFnData<TArgs>) => ResponseType<TArgs> | null;
-};
-export declare const withResponseUpdate: <TArgs extends QueryArgs>(options: WithResponseUpdateFeatureOptions<TArgs>) => QueryFeature<TArgs>;
-export {};

package/lib/experimental/http/query-repository.d.ts

@@ -1,69 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { DestroyRef, ErrorHandler } from '@angular/core';
-import { CreateHttpRequestClientOptions, HttpRequest } from './http-request';
-import { QueryArgs, RequestArgs } from './query';
-import { QueryClientConfig } from './query-client-config';
-import { QueryMethod, RouteType } from './query-creator';
-import { InternalRunQueryExecuteOptions, RunQueryExecuteOptions } from './query-execute-utils';
-export type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
-    /**
-     * The route of the request.
-     * @example '/users'
-     * @example (args) => `/users/${args.userId}`
-     */
-    route: RouteType<TArgs>;
-    /** The HTTP method of the request */
-    method: QueryMethod;
-    /** If the request is secure (needs authentication) */
-    isSecure?: boolean;
-    /** The data of the request */
-    args?: RequestArgs<TArgs> | null;
-    /** The client options of the request */
-    clientOptions?: CreateHttpRequestClientOptions;
-    /** If set, this request's cache key will be prefixed with this key */
-    key?: string;
-    /** The previous cache key of the request */
-    previousKey?: string | false;
-    /** The destroy ref to bind the request to. If the destroy ref is destroyed, the request will be destroyed as well. */
-    consumerDestroyRef: DestroyRef;
-    /** Configuration on how to run the query */
-    runQueryOptions?: RunQueryExecuteOptions;
-    /** Internal options for running the query */
-    internalRunQueryOptions?: InternalRunQueryExecuteOptions;
-};
-export type QueryRepositoryItem<TArgs extends QueryArgs> = {
-    /** The key of the request. If the key is `false`, the request is not cached, otherwise it is. */
-    key: QueryKeyOrNone;
-    /** The request object */
-    request: HttpRequest<TArgs>;
-};
-/**
- * The query repository is responsible for managing all requests and their consumers.
- * It will cache requests if they can be cached and reuse them if they are already cached.
- * It will also destroy requests if there are no more consumers left.
- */
-export type QueryRepository = {
-    /** Creates a new request. If the request is already cached, it will be reused. */
-    request: <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => QueryRepositoryItem<TArgs>;
-    /** Removes a consumer from a request by its key. Destroys the request if there are no more consumers left. */
-    unbind: (key: QueryKeyOrNone, consumerDestroyRef: DestroyRef) => boolean;
-    /** Removes all secure requests and their consumers */
-    unbindAllSecure: () => void;
-};
-/** The key of a query */
-export type QueryKey = string;
-/** A key that will not be cached */
-export type QueryKeyNoCache = false;
-/** A key that may or may not be cached */
-export type QueryKeyOrNone = QueryKey | QueryKeyNoCache;
-export type QueryRepositoryDependencies = {
-    /** The HTTP client to use for the requests */
-    httpClient: HttpClient;
-    /** The error handler to use for the requests */
-    ngErrorHandler: ErrorHandler;
-};
-export type CreateQueryRepositoryConfig = QueryClientConfig & {
-    /** The dependencies of the query repository */
-    dependencies: QueryRepositoryDependencies;
-};
-export declare const createQueryRepository: (config: CreateQueryRepositoryConfig) => QueryRepository;

package/lib/experimental/http/query-snapshot.d.ts

@@ -1,10 +0,0 @@
-import { QueryArgs, QuerySnapshot } from './query';
-import { QueryDependencies } from './query-dependencies';
-import { InternalQueryExecute } from './query-execute';
-import { QueryState } from './query-state';
-export type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
-    state: QueryState<TArgs>;
-    deps: QueryDependencies;
-    execute: InternalQueryExecute<TArgs>;
-};
-export declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQuerySnapshotOptions<TArgs>) => () => QuerySnapshot<TArgs>;

package/lib/experimental/http/query-stack.d.ts

@@ -1,109 +0,0 @@
-import { Signal } from '@angular/core';
-import { AnyQuery, RequestArgs, ResponseType } from './query';
-import { AnyQueryCreator, QueryArgsOf, RunQueryCreator } from './query-creator';
-import { QueryErrorResponse } from './query-error-response';
-import { QueryFeature } from './query-features';
-export type QueryStackSubtle<TCreator extends AnyQueryCreator, TQuery extends AnyQuery> = {
-    /** Create a new query with the given arguments. You should always prefer the `args` option instead of this. */
-    runWithArgs: (args: RequestArgs<QueryArgsOf<TCreator>> | RequestArgs<QueryArgsOf<TCreator>>[] | null) => TQuery | null;
-};
-export type QueryStack<TQuery extends AnyQuery, TCreator extends AnyQueryCreator, TTransform> = {
-    /** Contains all queries in the stack. */
-    queries: Signal<TQuery[]>;
-    /** Contains the first query in the stack. */
-    firstQuery: Signal<TQuery | null>;
-    /** Contains the last query in the stack. Useful for getting current pagination values. */
-    lastQuery: Signal<TQuery | null>;
-    /** True if any query in the stack is loading. */
-    loading: Signal<boolean>;
-    /** Contains the first error that occurred in the stack. */
-    error: Signal<QueryErrorResponse | null>;
-    /** Contains the responses of all queries in the stack. Will be `null` for queries that are loading or errored. */
-    response: Signal<TTransform>;
-    /** Executes all queries in the stack. */
-    execute: (options?: {
-        allowCache?: boolean;
-    }) => void;
-    /** Destroys all queries in the stack and empties it. This should only be used if `append` is true. */
-    clear: () => void;
-    /** Advanced query stack features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
-    subtle: QueryStackSubtle<TCreator, TQuery>;
-};
-export type AnyQueryStack = QueryStack<AnyQuery, AnyQueryCreator, any>;
-export type CreateQueryStackOptions<TCreator extends AnyQueryCreator, TDeps extends () => any, TTransform = (ResponseType<QueryArgsOf<TCreator>> | null)[]> = {
-    /**
-     * The query creator function that will be used to create the query stack.
-     */
-    queryCreator: TCreator;
-    /**
-     * The dependencies that should trigger a new query stack creation.
-     * This function can be treated like a computed function. It reacts to signal changes.
-     * The return value of this function will be passed to the `args` function.
-     *
-     * This option can be ignored if `append` is false.
-     */
-    dependencies?: TDeps;
-    /**
-     * The features that should be used for all queries in the stack.
-     *
-     * @throws If the `withArgs` feature is used. This feature is internally used.
-     *
-     * @example
-     * // Due to limitations in TypeScript, you have to manually add the needed generic types if needed.
-     * features: [E.withSuccessHandling<GetPostQueryArgs>({ handler: (post) => console.log(post.title) })]
-     *
-     * @example
-     * // If typings are not needed, you can use the feature without generics.
-     * features: [E.withPolling({ interval: 5000 })]
-     */
-    features?: QueryFeature<any>[];
-    /**
-     * The arguments to create queries with.
-     * This function can be treated like a computed function. It reacts to signal changes.
-     * If a signal changes, a new query will be created (and appended to the existing ones if `append` is true).
-     * If this function returns `null`, the args will be ignored.
-     * If this function returns an array, multiple queries will be created.
-     *
-     * @example
-     * // One query
-     * () => ({ queryParams: { postId: myId() } }),
-     *
-     * @example
-     * // Multiple queries (these can of cause also be created using a loop)
-     * () => [
-     *  { queryParams: { postId: myId() } },
-     *  { queryParams: { postId: myOtherId() } },
-     * ],
-     *
-     * @example
-     * // One query with dependencies
-     * (deps) => ({ queryParams: { postId: myId(), limit: deps.limit } }),
-     */
-    args: (deps: ReturnType<TDeps>) => RequestArgs<QueryArgsOf<TCreator>> | RequestArgs<QueryArgsOf<TCreator>>[] | null;
-    /**
-     * If true, new queries will be appended to the existing ones. Otherwise, existing queries will be destroyed.
-     * This should be used for things like infinite scrolling where already fetched queries should not be destroyed.
-     */
-    append?: boolean;
-    /**
-     * If append is true, this function will be called to merge the old and new queries.
-     * Useful if you want to append the new queries in a specific order (e.g. at the beginning).
-     */
-    appendFn?: (oldQueries: RunQueryCreator<TCreator>[], newQueries: RunQueryCreator<TCreator>[]) => {
-        /** The new queries merged with the old ones. */
-        queries: RunQueryCreator<TCreator>[];
-        /** The last query in the new queries. */
-        lastQuery: RunQueryCreator<TCreator> | null;
-    };
-    /**
-     * Transforms the responses of all queries in the stack. Useful for merging or filtering responses.
-     */
-    transform?: (responses: ResponseType<QueryArgsOf<TCreator>>[]) => TTransform;
-};
-/** Transforms an array of arrays into a single array and filters out `null` values. */
-export declare const transformArrayResponse: <T extends (unknown | null)[]>(responses: T) => NonNullable<T[0]>[];
-/** Transforms an array of paginated responses into a single array and filters out `null` values. */
-export declare const transformPaginatedResponse: <T extends ({
-    items: unknown[];
-} | null)[]>(responses: T) => NonNullable<NonNullable<T[0]>["items"]>;
-export declare const createQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TDeps extends () => any, TTransform = (ResponseType<TArgs> | null)[]>(options: CreateQueryStackOptions<TCreator, TDeps, TTransform>) => QueryStack<RunQueryCreator<TCreator>, TCreator, TTransform>;

package/lib/experimental/http/query-state.d.ts

@@ -1,41 +0,0 @@
-import { HttpEvent } from '@angular/common/http';
-import { Signal, WritableSignal } from '@angular/core';
-import { HttpRequest, HttpRequestLoadingState } from './http-request';
-import { QueryArgs, RequestArgs, ResponseType } from './query';
-import { QueryErrorResponse } from './query-error-response';
-export type SetupQueryStateOptions = {};
-export type QueryStateSubtle<TArgs extends QueryArgs> = {
-    request: WritableSignal<HttpRequest<TArgs> | null>;
-};
-export type QueryState<TArgs extends QueryArgs> = {
-    response: WritableSignal<ResponseType<TArgs> | null>;
-    args: WritableSignal<RequestArgs<TArgs> | null>;
-    latestHttpEvent: WritableSignal<HttpEvent<ResponseType<TArgs>> | null>;
-    loading: WritableSignal<HttpRequestLoadingState | null>;
-    error: WritableSignal<QueryErrorResponse | null>;
-    lastTimeExecutedAt: WritableSignal<number | null>;
-    executionState: Signal<QueryExecutionState<TArgs> | null>;
-    subtle: QueryStateSubtle<TArgs>;
-};
-export type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
-    type: 'success';
-    response: ResponseType<TArgs>;
-};
-export type QueryExecutionStateFailure = {
-    type: 'failure';
-    error: QueryErrorResponse;
-};
-export type QueryExecutionStateLoadingWithNoResponse = {
-    type: 'loading';
-    hasCachedResponse: false;
-    loading: HttpRequestLoadingState;
-};
-export type QueryExecutionStateLoadingWithCachedResponse<TArgs extends QueryArgs> = {
-    type: 'loading';
-    hasCachedResponse: true;
-    loading: HttpRequestLoadingState;
-    cachedResponse: ResponseType<TArgs>;
-};
-export type QueryExecutionStateLoading<TArgs extends QueryArgs> = QueryExecutionStateLoadingWithNoResponse | QueryExecutionStateLoadingWithCachedResponse<TArgs>;
-export type QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs> | QueryExecutionStateFailure | QueryExecutionStateLoading<TArgs>;
-export declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions) => QueryState<TArgs>;