@ethlete/query 5.38.0 → 5.40.0

package/lib/directives/query.directive.d.ts

@@ -1,9 +1,10 @@
 import { OnDestroy, OnInit } from '@angular/core';
+import { AnyLegacyQuery } from '../experimental';
 import { AnyQuery, AnyQueryCollection, QueryCollectionKeysOf, QueryOf } from '../query';
 import { QueryDataOf } from '../query-creator';
 import { RequestError, RequestProgress } from '../request';
 import * as i0 from "@angular/core";
-interface QueryContext<Q extends AnyQuery | AnyQueryCollection | null> {
+interface QueryContext<Q extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null> {
     /**
      * The queries's response data.
      */
@@ -37,7 +38,7 @@ interface QueryContext<Q extends AnyQuery | AnyQueryCollection | null> {
      */
     scope: QueryCollectionKeysOf<Q> | null;
 }
-export declare class QueryDirective<Q extends AnyQuery | AnyQueryCollection | null> implements OnInit, OnDestroy {
+export declare class QueryDirective<Q extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null> implements OnInit, OnDestroy {
     private _mainTemplateRef;
     private _viewContainerRef;
     private _errorHandler;
@@ -51,7 +52,7 @@ export declare class QueryDirective<Q extends AnyQuery | AnyQueryCollection | nu
     get cache(): boolean;
     set cache(v: boolean);
     private _cache;
-    static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryCollection | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<Q>;
+    static ngTemplateContextGuard<Q extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<Q>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     private _subscribeToQuery;

package/lib/experimental/http/http-request.d.ts

@@ -1,9 +1,10 @@
 import { HttpClient, HttpContext, HttpEvent } from '@angular/common/http';
-import { Signal } from '@angular/core';
+import { ErrorHandler, Signal } from '@angular/core';
 import { QueryArgs, RequestArgs, ResponseType } from './query';
 import { CacheAdapterFn } from './query-client-config';
 import { QueryMethod } from './query-creator';
 import { QueryErrorResponse } from './query-error-response';
+import { QueryRepositoryDependencies } from './query-repository';
 import { ShouldRetryRequestFn } from './query-utils';
 export declare const SPEED_BUFFER_TIME_IN_MS = 2000;
 export type HttpRequestTransferCacheConfig = boolean | {
@@ -13,6 +14,8 @@ export type HttpRequestResponseType = 'json' | 'text' | 'blob' | 'arraybuffer';
 export type CreateHttpRequestDependencies = {
     /** The http client instance to use for the request */
     httpClient: HttpClient;
+    /** The error handler instance to use for the request */
+    ngErrorHandler: ErrorHandler;
 };
 export type CreateHttpRequestClientOptions = {
     /**
@@ -58,7 +61,7 @@ export type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
     /** The data of the request */
     args?: RequestArgs<TArgs> | null;
     /** The dependencies of the request */
-    dependencies: CreateHttpRequestDependencies;
+    dependencies: QueryRepositoryDependencies;
     /** The client options of the request */
     clientOptions?: CreateHttpRequestClientOptions;
     /**

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

@@ -1,3 +1,4 @@
+import { Injector } from '@angular/core';
 import { HttpRequestResponseType, HttpRequestTransferCacheConfig } from './http-request';
 import { AnyQuery, PathParamsType, Query, QueryArgs } from './query';
 import { QueryClientConfig } from './query-client-config';
@@ -69,6 +70,10 @@ export type QueryConfig = {
      * 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>[];

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

@@ -1,8 +1,11 @@
-import { DestroyRef, EnvironmentInjector, ɵEffectScheduler } from '@angular/core';
+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. */
@@ -15,5 +18,9 @@ export type QueryDependencies = {
     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-repository.d.ts

@@ -1,4 +1,5 @@
-import { DestroyRef } from '@angular/core';
+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';
@@ -24,7 +25,7 @@ export type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
     /** 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. */
-    destroyRef: DestroyRef;
+    consumerDestroyRef: DestroyRef;
     /** Configuration on how to run the query */
     runQueryOptions?: RunQueryExecuteOptions;
     /** Internal options for running the query */
@@ -45,7 +46,7 @@ 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, destroyRef: DestroyRef) => boolean;
+    unbind: (key: QueryKeyOrNone, consumerDestroyRef: DestroyRef) => boolean;
     /** Removes all secure requests and their consumers */
     unbindAllSecure: () => void;
 };
@@ -55,4 +56,14 @@ export type QueryKey = string;
 export type QueryKeyNoCache = false;
 /** A key that may or may not be cached */
 export type QueryKeyOrNone = QueryKey | QueryKeyNoCache;
-export declare const createQueryRepository: (config: QueryClientConfig) => QueryRepository;
+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/index.d.ts

@@ -1,5 +1,6 @@
 export * from './auth';
 export * from './gql';
 export * from './http';
+export * from './interop';
 export * from './pipes';
 export * from './ws';

package/lib/experimental/interop/index.d.ts

@@ -0,0 +1,2 @@
+export * from './legacy-query';
+export * from './legacy-query-creator';

package/lib/experimental/interop/legacy-query-creator.d.ts

@@ -0,0 +1,45 @@
+import { HttpHeaders } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { EntityStore } from '../../entity';
+import { BaseArguments, EmptyObject, QueryConfig, QueryEntityConfig, RouteType, WithHeaders, WithInjector } from '../../query';
+import { QueryContainerConfig } from '../../utils';
+import { AnyQuery, Query, QueryArgs, QueryCreator, ResponseType } from '../http';
+import { LegacyQuery } from './legacy-query';
+export type LegacyArgumentsOfQueryArgs<T extends QueryArgs> = Omit<T, 'response' | 'headers'> & WithHeaders;
+export type QueryArgsOfLegacyArguments<T extends BaseArguments | undefined, J> = Omit<T, 'mock' | 'headers'> & {
+    headers?: HttpHeaders;
+    response?: J;
+};
+export type CreateLegacyQueryCreatorOptions<TArgs extends QueryArgs, Response, Store extends EntityStore<unknown>, Data, Id> = {
+    creator: QueryCreator<TArgs>;
+    /**
+     * Object containing the query's entity store information.
+     */
+    entity?: QueryEntityConfig<Store, Data, Response, LegacyArgumentsOfQueryArgs<TArgs>, Id>;
+};
+export interface WithLegacyConfig {
+    /**
+     * Additional configuration for this query.
+     */
+    config?: QueryConfig & {
+        /**
+         * If set to true, the query will be destroyed when it either succeeds or fails.
+         */
+        destroyOnResponse?: boolean;
+    };
+}
+export type LegacyQueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id, TNewQuery extends AnyQuery> = Arguments extends BaseArguments ? (args: Arguments & WithHeaders & WithLegacyConfig & WithInjector) => LegacyQuery<Response, Arguments, Route, Store, Data, Id, TNewQuery> : (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithLegacyConfig & WithInjector) => LegacyQuery<Response, Arguments, Route, Store, Data, Id, TNewQuery>;
+export type AnyLegacyQueryCreator = LegacyQueryCreator<any, any, any, any, any>;
+/**
+ * Creates a legacy query creator.
+ * @deprecated This is a temporary solution to support legacy queries. It will be removed in the future.
+ */
+export declare class LegacyQueryCreator<TArgs extends QueryArgs, Response extends ResponseType<TArgs>, Store extends EntityStore<unknown>, Id, Data = Response> {
+    options: CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>;
+    constructor(options: CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>);
+    prepare: LegacyQueryPrepareFn<LegacyArgs, Response, Route, Store, Data, Id, Query<TArgs>>;
+    createSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<LegacyQuery<Response, LegacyArgs, Route, Store, Data, Id, Query<TArgs>> | null>;
+    createSignal: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => import("@angular/core").WritableSignal<LegacyQuery<Response, LegacyArgs, Route, Store, Data, Id, Query<TArgs>> | null>;
+    behaviorSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<LegacyQuery<Response, LegacyArgs, Route, Store, Data, Id, Query<TArgs>> | null>;
+}
+export declare const createLegacyQueryCreator: <TArgs extends QueryArgs, Response extends ResponseType<TArgs>, Store extends EntityStore<unknown>, Id, Data = Response>(options: CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>) => LegacyQueryCreator<TArgs, Response, Store, Id, Data>;

package/lib/experimental/interop/legacy-query.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { EntityStore } from '../../entity';
+import { BaseArguments, ExecuteQueryOptions, PollConfig, QueryAutoRefreshConfig, QueryEntityConfig, QueryState, RouteType } from '../../query';
+import { RequestError } from '../../request';
+import { AnyQuery, Query, QueryArgs, QueryArgsOf, RequestArgs } from '../http';
+export type CreateLegacyQueryOptions<TArgs extends QueryArgs> = {
+    query: Query<TArgs>;
+};
+export declare const isLegacyQuery: <T extends AnyLegacyQuery>(query: unknown) => query is T;
+export type AnyLegacyQuery = LegacyQuery<any, any, any, any, any, any, any>;
+export declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id, TNewQuery extends AnyQuery> {
+    private newQuery;
+    _arguments: RequestArgs<QueryArgsOf<TNewQuery>>;
+    private entity?;
+    private _pollingSubscription;
+    private _currentPollConfig;
+    private storeSyncEffect;
+    state$: Observable<QueryState<Data>>;
+    get rawState(): QueryState<any>;
+    get isExpired(): boolean;
+    get isInUse(): boolean;
+    get isPolling(): boolean;
+    get autoRefreshOnConfig(): Readonly<QueryAutoRefreshConfig>;
+    get store(): null;
+    get canBeCached(): boolean;
+    get _isInMockMode(): boolean;
+    constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined);
+    destroy(): void;
+    execute(options?: ExecuteQueryOptions): this;
+    abort(): this;
+    poll(config: PollConfig): this;
+    stopPolling(): this;
+    pausePolling(): this;
+    resumePolling(): this;
+    onSuccess(callback: (response: Data) => void): this;
+    onFailure(callback: (error: RequestError<unknown>) => void): this;
+    private _transformState;
+}

package/lib/infinite-query/infinity-query.d.ts

@@ -1,7 +1,8 @@
 import { Observable } from 'rxjs';
+import { AnyLegacyQueryCreator } from '../experimental';
 import { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryDataOf } from '../query-creator';
 import { InfinityQueryConfig } from './infinity-query.types';
-export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query extends ConstructQuery<QueryCreator>, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]> {
+export declare class InfinityQuery<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, Query extends ConstructQuery<QueryCreator>, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]> {
     private _config;
     private _destroy$;
     private readonly _queries$;

package/lib/infinite-query/infinity-query.types.d.ts

@@ -1,3 +1,4 @@
+import { AnyLegacyQueryCreator } from '../experimental';
 import { BaseArguments, WithHeaders } from '../query';
 import { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryDataOf } from '../query-creator';
 import { InfinityQuery } from './infinity-query';
@@ -13,7 +14,7 @@ export interface TotalPagesExtractorOptions<Arguments extends BaseArguments | un
     itemsPerPage: number;
     args: Arguments;
 }
-export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Arguments extends BaseArguments | undefined, QueryResponse, InfinityResponse extends unknown[]> {
+export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, Arguments extends BaseArguments | undefined, QueryResponse, InfinityResponse extends unknown[]> {
     /**
      * The query creator to use for fetching pages.
      */
@@ -99,6 +100,6 @@ export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Argum
 type OmitUndefined<T> = T extends undefined ? never : T;
 export type AnyInfinityQueryConfig = InfinityQueryConfig<any, any, any, any>;
 export type AnyInfinityQuery = InfinityQuery<any, any, any, any, any>;
-export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryArgsOf<QueryCreator>>, QueryDataOf<QueryCreator>, InfinityResponse>;
+export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryArgsOf<QueryCreator>>, QueryDataOf<QueryCreator>, InfinityResponse>;
 export type InfinityQueryOf<Cfg extends AnyInfinityQueryConfig | null> = InfinityQuery<NonNullable<Cfg>['queryCreator'], ConstructQuery<NonNullable<Cfg>['queryCreator']>, QueryArgsOf<NonNullable<Cfg>['queryCreator']>, QueryDataOf<NonNullable<Cfg>['queryCreator']>, NonNullable<Cfg>['response']['arrayType']>;
 export {};

package/lib/infinite-query/infinity-query.utils.d.ts

@@ -1,4 +1,5 @@
+import { AnyLegacyQueryCreator } from '../experimental';
 import { AnyQueryCreator, QueryArgsOf, QueryDataOf } from '../query-creator';
 import { InfinityQueryConfig, PageParamCalculatorOptions } from './infinity-query.types';
-export declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
+export declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
 export declare const skipPaginationPageParamCalculator: ({ page, itemsPerPage }: PageParamCalculatorOptions) => number;

package/lib/query/query.types.d.ts

@@ -1,5 +1,7 @@
+import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
 import { EntityStore } from '../entity';
+import { AnyLegacyQuery, AnyLegacyQueryCreator } from '../experimental';
 import { AnyQueryCreator, ConstructQuery, QueryDataOf, QueryResponseOf } from '../query-creator';
 import { QueryForm } from '../query-form';
 import { Method, PathParams, QueryParams, RequestError, RequestHeaders, RequestProgress } from '../request';
@@ -258,6 +260,9 @@ export interface WithConfig {
      */
     config?: QueryConfig;
 }
+export interface WithInjector {
+    injector?: Injector;
+}
 export interface WithVariables {
     /**
      * The variables for the query. (graphql only)
@@ -361,10 +366,10 @@ export type QueryState<Response = unknown> = Loading | Success<Response> | Failu
 export type QueryStateResponseOf<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
 export type AnyQuery = Query<any, any, any, any, any, any>;
 export type AnyQueryCreatorCollection = {
-    [name: string]: AnyQueryCreator;
+    [name: string]: AnyQueryCreator | AnyLegacyQueryCreator;
 };
 export type QueryCollectionOf<T extends {
-    [name: string]: AnyQueryCreator;
+    [name: string]: AnyQueryCreator | AnyLegacyQueryCreator;
 }> = {
     [K in keyof T]: {
         type: K;
@@ -372,10 +377,10 @@ export type QueryCollectionOf<T extends {
     };
 }[keyof T];
 export type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;
-export type QueryOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
+export type QueryOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyLegacyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
 export type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;
 export type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;
-export type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQueryCollection ? T['type'] : never;
+export type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyQuery | null> = T extends AnyQueryCollection ? T['type'] : never;
 export type QueryCollectionWithNullableQuery<T extends AnyQueryCollection | null> = T extends null ? never : {
     [K in keyof T]: T[K] extends string ? T[K] : T[K] | null;
 };

package/lib/query/query.utils.d.ts

@@ -1,6 +1,7 @@
 import { Paginated } from '@ethlete/types';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { EntityStore } from '../entity';
+import { AnyLegacyQuery } from '../experimental';
 import { QueryClient } from '../query-client';
 import { AnyQueryCreator, QueryArgsOf, QueryCreator, QueryDataOf, QueryResponseOf, QueryStoreIdOf, QueryStoreOf } from '../query-creator';
 import { QueryForm } from '../query-form';
@@ -35,7 +36,7 @@ export declare const isQueryCollection: <T extends AnyQueryCollection>(query: un
 export declare const createQueryCollection: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T) => BehaviorSubject<R | null>;
 export declare const createQueryCollectionSubject: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => BehaviorSubject<R | null>;
 export declare const createQueryCollectionSignal: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => import("@angular/core").WritableSignal<R | null>;
-export declare const extractQuery: <T extends AnyQuery | AnyQueryCollection | null>(v: T) => import("@ethlete/query").Query<any, any, any, any, any, any> | null;
+export declare const extractQuery: <T extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>(v: T) => import("@ethlete/query").Query<any, any, any, any, any, any> | (T & AnyLegacyQuery) | import("../experimental").LegacyQuery<any, LegacyArgs, Route, any, any, any, import("../experimental").Query<any>> | null;
 export declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
 export declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryArgsOf<QC>, Response extends QueryResponseOf<QC>, Store extends QueryStoreOf<QC>, Data extends QueryDataOf<QC>, Route extends RouteType<Arguments>, Id extends QueryStoreIdOf<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response | undefined>(config: {
     creator: QC;

package/lib/query-creator/query-creator.types.d.ts

@@ -1,13 +1,14 @@
 import { EntityStore } from '../entity';
+import { AnyLegacyQuery, AnyLegacyQueryCreator, LegacyArgumentsOfQueryArgs, LegacyQuery, LegacyQueryCreator } from '../experimental';
 import { Query } from '../query/query';
 import { AnyQuery, BaseArguments, EmptyObject, RouteType, WithConfig, WithHeaders, WithMock } from '../query/query.types';
 import { QueryCreator } from './query-creator';
 export type QueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> = Arguments extends BaseArguments ? (args: Arguments & WithHeaders & WithConfig & WithMock<Response>) => Query<Response, Arguments, Route, Store, Data, Id> : (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithConfig & WithMock<Response>) => Query<Response, Arguments, Route, Store, Data, Id>;
 export type AnyQueryCreator = QueryCreator<any, any, any, any, any, any>;
-export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<infer Args, any, any, any, any, any> ? Args : T extends Query<any, infer Args, any, any, any, any> ? Args : never;
-export type QueryResponseOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, infer Response, any, any, any, any> ? Response : T extends Query<infer Response, any, any, any, any, any> ? Response : never;
-export type QueryRouteOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, infer Route, any, any, any> ? Route : T extends Query<any, any, infer Route, any, any, any> ? Route : never;
-export type QueryStoreOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, infer Store, any, any> ? Store : T extends Query<any, any, any, infer Store, any, any> ? Store : never;
-export type QueryDataOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, infer Data, any> ? Data : T extends Query<any, any, any, any, infer Data, any> ? Data : never;
-export type QueryStoreIdOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, any, infer StoreId> ? StoreId : T extends Query<any, any, any, any, any, infer StoreId> ? StoreId : never;
-export type ConstructQuery<T extends AnyQueryCreator> = ReturnType<T['prepare']>;
+export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<infer Args, any, any, any, any, any> ? Args : T extends Query<any, infer Args, any, any, any, any> ? Args : T extends LegacyQuery<any, infer Args, any, any, any, any, any> ? Args : T extends LegacyQueryCreator<infer Args, any, any, any, any> ? LegacyArgumentsOfQueryArgs<Args> : never;
+export type QueryResponseOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, infer Response, any, any, any, any> ? Response : T extends Query<infer Response, any, any, any, any, any> ? Response : T extends LegacyQuery<infer Response, any, any, any, any, any, any> ? Response : T extends LegacyQueryCreator<any, infer Response, any, any, any> ? Response : never;
+export type QueryRouteOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, any, infer Route, any, any, any> ? Route : T extends Query<any, any, infer Route, any, any, any> ? Route : T extends LegacyQuery<any, any, infer Route, any, any, any, any> ? Route : T extends LegacyQueryCreator<infer Args, any, any, any, any> ? RouteType<LegacyArgumentsOfQueryArgs<Args>> : never;
+export type QueryStoreOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, any, any, infer Store, any, any> ? Store : T extends Query<any, any, any, infer Store, any, any> ? Store : T extends LegacyQuery<any, any, any, infer Store, any, any, any> ? Store : T extends LegacyQueryCreator<any, any, infer Store, any, any> ? Store : never;
+export type QueryDataOf<T extends AnyQueryCreator | AnyLegacyQuery | AnyLegacyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, infer Data, any> ? Data : T extends Query<any, any, any, any, infer Data, any> ? Data : T extends LegacyQuery<any, any, any, any, infer Data, any, any> ? Data : T extends LegacyQueryCreator<any, any, any, any, infer Data> ? Data : never;
+export type QueryStoreIdOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, any, any, any, any, infer StoreId> ? StoreId : T extends Query<any, any, any, any, any, infer StoreId> ? StoreId : T extends LegacyQuery<any, any, any, any, any, infer StoreId, any> ? StoreId : T extends LegacyQueryCreator<any, any, any, infer StoreId, any> ? StoreId : never;
+export type ConstructQuery<T extends AnyQueryCreator | AnyLegacyQueryCreator> = ReturnType<T['prepare']>;

package/lib/utils/data.utils.d.ts

@@ -1,6 +1,7 @@
-import { CreateComputedOptions, Signal } from '@angular/core';
+import { CreateComputedOptions, Injector, Signal } from '@angular/core';
 import { ToObservableOptions, ToSignalOptions } from '@angular/core/rxjs-interop';
 import { Observable, Subscribable } from 'rxjs';
+import { AnyLegacyQuery } from '../experimental';
 import { AnyQuery, AnyQueryCollection, QueryOf, QueryState } from '../query';
 import { QueryDataOf } from '../query-creator';
 export interface QueryContainerConfig {
@@ -27,36 +28,37 @@ export interface QueryFilterConfig {
      */
     cacheResponse?: boolean;
 }
-export declare const addQueryContainerHandling: (obs: Observable<AnyQuery | AnyQuery[] | null>, valueFn: () => AnyQuery | AnyQuery[] | null | undefined, config?: QueryContainerConfig) => void;
-export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
-export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
+export declare const addQueryContainerHandling: (obs: Observable<AnyQuery | AnyQuery[] | AnyLegacyQuery | AnyLegacyQuery[] | null>, valueFn: () => AnyQuery | AnyQuery[] | AnyLegacyQuery | AnyLegacyQuery[] | null | undefined, config?: QueryContainerConfig) => void;
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
     initialValue?: undefined;
     requireSync?: false;
 } & QueryContainerConfig): Signal<T | undefined>;
-export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
     initialValue?: null;
     requireSync?: false;
 } & QueryContainerConfig): Signal<T | null>;
-export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
     initialValue?: undefined;
     requireSync: true;
 } & QueryContainerConfig): Signal<T>;
-export declare function toQuerySignal<T extends AnyQuery | null, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
     initialValue: U;
     requireSync?: false;
 } & QueryContainerConfig): Signal<T | U>;
-export declare function queryComputed<T extends AnyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+export declare function effectComputed<T extends AnyQuery | AnyLegacyQuery | AnyQuery[] | AnyLegacyQuery[] | null>(computation: () => T, injector: Injector): Signal<T>;
+export declare function queryComputed<T extends AnyQuery | AnyLegacyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
 /**
  * Creates a signal that will only be reactive until the first query is created.
  * All subsequent changes inside the computation will be ignored.
  */
-export declare function queryComputedTillTruthy<T extends AnyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T | null>;
-export declare function queryArrayComputed<T extends AnyQuery[] | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
-export declare function toQuerySubject<T extends AnyQuery | null>(source: Signal<T>, options?: ToObservableOptions & QueryContainerConfig): Observable<T>;
-export declare function queryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): import("@angular/core").WritableSignal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
-export type QueryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>> = Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null> & {
+export declare function queryComputedTillTruthy<T extends AnyQuery | AnyLegacyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T | null>;
+export declare function queryArrayComputed<T extends AnyQuery[] | AnyLegacyQuery[] | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+export declare function toQuerySubject<T extends AnyQuery | AnyLegacyQuery | null>(source: Signal<T>, options?: ToObservableOptions & QueryContainerConfig): Observable<T>;
+export declare function queryStateSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): import("@angular/core").WritableSignal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
+export type QueryStateSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>> = Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null> & {
     reset: () => void;
 };
-export declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): QueryStateSignal<T>;
-export declare function queryStateErrorSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T): Signal<import("@ethlete/query").RequestError<unknown> | null>;
-export declare function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T): Signal<import("../query").Loading | null>;
+export declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): QueryStateSignal<T>;
+export declare function queryStateErrorSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T): Signal<import("@ethlete/query").RequestError<unknown> | null>;
+export declare function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T): Signal<import("../query").Loading | null>;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "5.38.0",
+  "version": "5.40.0",
+  "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {
-    "@angular/common": "19.2.6",
-    "@angular/core": "19.2.6",
-    "@angular/forms": "19.2.6",
-    "@angular/router": "19.2.6",
+    "@angular/common": "19.2.11",
+    "@angular/core": "19.2.11",
+    "@angular/forms": "19.2.11",
+    "@angular/router": "19.2.11",
     "@ethlete/core": "^4.0.3",
     "@ethlete/types": "^1.6.2",
     "rxjs": "7.8.2",