@tanstack/angular-query-experimental 5.34.1 → 5.35.0

package/build/infinite-query-options.d.ts

@@ -1,18 +0,0 @@
-import type { DataTag } from '@tanstack/query-core';
-import type { InfiniteData } from '@tanstack/query-core';
-import type { CreateInfiniteQueryOptions } from './types';
-import type { DefaultError, QueryKey } from '@tanstack/query-core';
-export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam> & {
-    initialData?: undefined;
-};
-type NonUndefinedGuard<T> = T extends undefined ? never : T;
-export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam> & {
-    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
-};
-export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
-};
-export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
-};
-export {};

package/build/inject-infinite-query.d.ts

@@ -1,7 +0,0 @@
-import type { Injector } from '@angular/core';
-import type { DefaultError, InfiniteData, QueryClient, QueryKey } from '@tanstack/query-core';
-import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult, DefinedCreateInfiniteQueryResult } from './types';
-import type { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from './infinite-query-options';
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: (client: QueryClient) => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, injector?: Injector): CreateInfiniteQueryResult<TData, TError>;
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: (client: QueryClient) => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, injector?: Injector): DefinedCreateInfiniteQueryResult<TData, TError>;
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: (client: QueryClient) => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, injector?: Injector): CreateInfiniteQueryResult<TData, TError>;

package/build/inject-is-fetching.d.ts

@@ -1,3 +0,0 @@
-import { type QueryFilters } from '@tanstack/query-core';
-import type { Injector, Signal } from '@angular/core';
-export declare function injectIsFetching(filters?: QueryFilters, injector?: Injector): Signal<number>;

package/build/inject-is-mutating.d.ts

@@ -1,3 +0,0 @@
-import { type MutationFilters } from '@tanstack/query-core';
-import type { Injector, Signal } from '@angular/core';
-export declare function injectIsMutating(filters?: MutationFilters, injector?: Injector): Signal<number>;

package/build/inject-mutation-state.d.ts

@@ -1,11 +0,0 @@
-import { type DefaultError, type Mutation, type MutationFilters, type MutationState } from '@tanstack/query-core';
-import type { Injector, Signal } from '@angular/core';
-type MutationStateOptions<TResult = MutationState> = {
-    filters?: MutationFilters;
-    select?: (mutation: Mutation<unknown, DefaultError, unknown, unknown>) => TResult;
-};
-export interface InjectMutationStateOptions {
-    injector?: Injector;
-}
-export declare function injectMutationState<TResult = MutationState>(mutationStateOptionsFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
-export {};

package/build/inject-mutation.d.ts

@@ -1,4 +0,0 @@
-import { Injector } from '@angular/core';
-import type { DefaultError, QueryClient } from '@tanstack/query-core';
-import type { CreateMutationOptions, CreateMutationResult } from './types';
-export declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: (client: QueryClient) => CreateMutationOptions<TData, TError, TVariables, TContext>, injector?: Injector): CreateMutationResult<TData, TError, TVariables, TContext>;

package/build/inject-queries.d.ts

@@ -1,71 +0,0 @@
-import type { Injector, Signal } from '@angular/core';
-import type { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryFunction, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken, ThrowOnError } from '@tanstack/query-core';
-type QueryObserverOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'placeholderData'> & {
-    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
-};
-type MAXIMUM_DEPTH = 20;
-type GetOptions<T> = T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-    data: infer TData;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? QueryObserverOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverOptionsForCreateQueries<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipToken;
-    select: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipToken;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TQueryFnData, TQueryKey> : QueryObserverOptionsForCreateQueries;
-type GetResults<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
-} ? QueryObserverResult<TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? QueryObserverResult<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? QueryObserverResult<TData, TError> : T extends [any, infer TError, infer TData] ? QueryObserverResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? QueryObserverResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverResult<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<unknown, any>;
-    select: (data: any) => infer TData;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? QueryObserverResult<TData, unknown extends TError ? DefaultError : TError> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any>;
-    throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? QueryObserverResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : QueryObserverResult;
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- */
-export type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
-    ...Tail
-], [
-    ...TResult,
-    GetOptions<Head>
-], [
-    ...TDepth,
-    1
-]> : ReadonlyArray<unknown> extends T ? T : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
-/**
- * QueriesResults reducer recursively maps type param to results
- */
-export type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
-    ...Tail
-], [
-    ...TResult,
-    GetResults<Head>
-], [
-    ...TDepth,
-    1
-]> : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>> ? Array<QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError>> : Array<QueryObserverResult>;
-export declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
-    queries: Signal<[...QueriesOptions<T>]>;
-    combine?: (result: QueriesResults<T>) => TCombinedResult;
-}, injector?: Injector): Signal<TCombinedResult>;
-export {};

package/build/inject-query-client.d.ts

@@ -1,13 +0,0 @@
-import type { QueryClient } from '@tanstack/query-core';
-declare const injectQueryClient: {
-    (): QueryClient;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false;
-    } & {
-        injector?: import("@angular/core").Injector;
-    }): QueryClient;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        injector?: import("@angular/core").Injector;
-    }): QueryClient;
-}, provideQueryClient: ((value: QueryClient | (() => QueryClient)) => import("@angular/core").Provider) & ((value: QueryClient | (() => QueryClient)) => import("@angular/core").Provider), QUERY_CLIENT: import("@angular/core").InjectionToken<QueryClient>;
-export { injectQueryClient, provideQueryClient, QUERY_CLIENT };

package/build/inject-query.d.ts

@@ -1,7 +0,0 @@
-import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core';
-import type { Injector } from '@angular/core';
-import type { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types';
-import type { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-options';
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: (client: QueryClient) => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: (client: QueryClient) => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): DefinedCreateQueryResult<TData, TError>;
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: (client: QueryClient) => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;

package/build/providers.d.ts

@@ -1,3 +0,0 @@
-import type { EnvironmentProviders } from '@angular/core';
-import type { QueryClient } from '@tanstack/query-core';
-export declare function provideAngularQuery(queryClient: QueryClient): EnvironmentProviders;

package/build/query-options.d.ts

@@ -1,16 +0,0 @@
-import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core';
-import type { CreateQueryOptions } from './types';
-export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData?: undefined;
-};
-type NonUndefinedGuard<T> = T extends undefined ? never : T;
-export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
-};
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    queryKey: DataTag<TQueryKey, TQueryFnData>;
-};
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    queryKey: DataTag<TQueryKey, TQueryFnData>;
-};
-export {};

package/build/signal-proxy.d.ts

@@ -1,13 +0,0 @@
-import type { Signal } from '@angular/core';
-export type MapToSignals<T> = {
-    [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>;
-};
-/**
- * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
- *
- * Functions on the object are passed through as-is.
- *
- * @param inputSignal - `Signal` that must return an object.
- *
- */
-export declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;

package/build/types.d.ts

@@ -1,44 +0,0 @@
-import type { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, QueryKey, QueryObserverOptions, QueryObserverResult } from '@tanstack/query-core';
-import type { MapToSignals } from './signal-proxy';
-export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-}
-export interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
-}
-type CreateStatusBasedQueryResult<TStatus extends QueryObserverResult['status'], TData = unknown, TError = DefaultError> = Extract<QueryObserverResult<TData, TError>, {
-    status: TStatus;
-}>;
-export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
-    isSuccess: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'success', TData, TError>>;
-    isError: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'error', TData, TError>>;
-    isPending: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'pending', TData, TError>>;
-}
-export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'suspense'> {
-}
-export type CreateBaseQueryResult<TData = unknown, TError = DefaultError, TState = QueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
-export type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
-export type DefinedCreateQueryResult<TData = unknown, TError = DefaultError, TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>> = MapToSignals<TDefinedQueryObserver>;
-export type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>;
-export type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError, TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<TData, TError>> = MapToSignals<TDefinedInfiniteQueryObserver>;
-export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
-}
-export type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-export type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-export type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
-    mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
-}> & {
-    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
-};
-type CreateStatusBasedMutationResult<TStatus extends CreateBaseMutationResult['status'], TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Extract<CreateBaseMutationResult<TData, TError, TVariables, TContext>, {
-    status: TStatus;
-}>;
-export interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> {
-    isSuccess: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'success', TData, TError, TVariables, TContext>>;
-    isError: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'error', TData, TError, TVariables, TContext>>;
-    isPending: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'pending', TData, TError, TVariables, TContext>>;
-    isIdle: (this: CreateMutationResult<TData, TError, TVariables, TContext>) => this is CreateMutationResult<TData, TError, TVariables, TContext, CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TContext>>;
-}
-export type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown, TState = CreateStatusBasedMutationResult<CreateBaseMutationResult['status'], TData, TError, TVariables, TContext>> = BaseMutationNarrowing<TData, TError, TVariables, TContext> & MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>;
-type Override<TTargetA, TTargetB> = {
-    [AKey in keyof TTargetA]: AKey extends keyof TTargetB ? TTargetB[AKey] : TTargetA[AKey];
-};
-export {};

package/build/util/assert-injector/assert-injector.d.ts

@@ -1,54 +0,0 @@
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-import { Injector } from '@angular/core';
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
- * whether it is the default `Injector` within the current **Injection Context**
- * or the custom `Injector` that was passed in.
- *
- * @template {() => any} Runner - Runner is a function that can return anything
- * @param {Function} fn - the Function to pass in `assertInInjectionContext`
- * @param {Injector | undefined | null} injector - the optional "custom" Injector
- * @param {Runner} runner - the runner fn
- * @returns {ReturnType<Runner>} result - returns the result of the Runner
- *
- * @example
- * ```ts
- * function injectValue(injector?: Injector) {
- *  return assertInjector(injectValue, injector, () => 'value');
- * }
- *
- * injectValue(); // string
- * ```
- */
-export declare function assertInjector<TRunner extends () => any>(fn: Function, injector: Injector | undefined | null, runner: TRunner): ReturnType<TRunner>;
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
- * within the current **Injection Context** or the custom `Injector` that was passed in.
- *
- * @param {Function} fn - the Function to pass in `assertInInjectionContext`
- * @param {Injector | undefined | null} injector - the optional "custom" Injector
- * @returns Injector
- *
- * @example
- * ```ts
- * function injectDestroy(injector?: Injector) {
- *  injector = assertInjector(injectDestroy, injector);
- *
- *  return runInInjectionContext(injector, () => {
- *    // code
- *  })
- * }
- * ```
- */
-export declare function assertInjector(fn: Function, injector: Injector | undefined | null): Injector;

package/build/util/create-injection-token/create-injection-token.d.ts

@@ -1,52 +0,0 @@
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-import { type EnvironmentProviders, type Host, type InjectOptions, InjectionToken, type Injector, type Optional, type Provider, type Self, type SkipSelf, type Type } from '@angular/core';
-type CreateInjectionTokenDep<TTokenType> = Type<TTokenType> | (abstract new (...args: Array<any>) => TTokenType) | InjectionToken<TTokenType>;
-type CreateInjectionTokenDeps<TFactory extends (...args: Array<any>) => any, TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>> = {
-    [Index in keyof TFactoryDeps]: CreateInjectionTokenDep<TFactoryDeps[Index]> | [
-        ...modifiers: Array<Optional | Self | SkipSelf | Host>,
-        token: CreateInjectionTokenDep<TFactoryDeps[Index]>
-    ];
-} & {
-    length: TFactoryDeps['length'];
-};
-type CreateInjectionTokenOptions<TFactory extends (...args: Array<any>) => any, TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>> = (TFactoryDeps[0] extends undefined ? {
-    deps?: never;
-} : {
-    deps: CreateInjectionTokenDeps<TFactory, TFactoryDeps>;
-}) & {
-    isRoot?: boolean;
-    multi?: boolean;
-    token?: InjectionToken<ReturnType<TFactory>>;
-    extraProviders?: Provider | EnvironmentProviders;
-};
-type InjectFn<TFactoryReturn> = {
-    (): TFactoryReturn;
-    (injectOptions: InjectOptions & {
-        optional?: false;
-    } & {
-        injector?: Injector;
-    }): TFactoryReturn;
-    (injectOptions: InjectOptions & {
-        injector?: Injector;
-    }): TFactoryReturn | null;
-};
-type ProvideFn<TNoop extends boolean, TFactoryReturn, TReturn = TFactoryReturn extends Array<infer Item> ? Item : TFactoryReturn> = (TNoop extends true ? (value: TReturn | (() => TReturn)) => Provider : () => Provider) & (TReturn extends Function ? (value: TReturn | (() => TReturn), isFunctionValue: boolean) => Provider : (value: TReturn | (() => TReturn)) => Provider);
-type CreateInjectionTokenReturn<TFactoryReturn, TNoop extends boolean = false> = [
-    InjectFn<TFactoryReturn>,
-    ProvideFn<TNoop, TFactoryReturn>,
-    InjectionToken<TFactoryReturn>,
-    () => Provider
-];
-export declare function createNoopInjectionToken<TValue, TMulti extends boolean = false, TOptions = Pick<CreateInjectionTokenOptions<() => void, []>, 'extraProviders'> & (TMulti extends true ? {
-    multi: true;
-} : Record<string, never>)>(description: string, options?: TOptions): CreateInjectionTokenReturn<TMulti extends true ? TValue[] : TValue, true>;
-export {};

package/build/util/index.d.ts

@@ -1,2 +0,0 @@
-export declare function shouldThrowError<T extends (...args: Array<any>) => boolean>(throwError: boolean | T | undefined, params: Parameters<T>): boolean;
-export declare function noop(): void;

package/build/util/lazy-init/lazy-init.d.ts

@@ -1 +0,0 @@
-export declare function lazyInit<T extends object>(initializer: () => T): T;

package/build/util/lazy-signal-initializer/lazy-signal-initializer.d.ts

@@ -1,4 +0,0 @@
-import { Injector, type Signal } from '@angular/core';
-type SignalInitializerFn<T> = (injector: Injector) => Signal<T>;
-export declare function lazySignalInitializer<T>(initializerFn: SignalInitializerFn<T>): Signal<T>;
-export {};

package/src/__tests__/inject-infinite-query.test.ts

@@ -1,64 +0,0 @@
-import { TestBed } from '@angular/core/testing'
-import { QueryClient } from '@tanstack/query-core'
-import { afterEach } from 'vitest'
-import { injectInfiniteQuery } from '../inject-infinite-query'
-import { provideAngularQuery } from '../providers'
-import { expectSignals, infiniteFetcher } from './test-utils'
-
-const QUERY_DURATION = 1000
-
-const resolveQueries = () => vi.advanceTimersByTimeAsync(QUERY_DURATION)
-
-describe('injectInfiniteQuery', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-    vi.useFakeTimers()
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  test('should properly execute infinite query', async () => {
-    const query = TestBed.runInInjectionContext(() => {
-      return injectInfiniteQuery(() => ({
-        queryKey: ['infiniteQuery'],
-        queryFn: infiniteFetcher,
-        initialPageParam: 0,
-        getNextPageParam: () => 12,
-      }))
-    })
-
-    expectSignals(query, {
-      data: undefined,
-      status: 'pending',
-    })
-
-    await resolveQueries()
-
-    expectSignals(query, {
-      data: {
-        pageParams: [0],
-        pages: ['data on page 0'],
-      },
-      status: 'success',
-    })
-
-    void query.fetchNextPage()
-
-    await resolveQueries()
-
-    expectSignals(query, {
-      data: {
-        pageParams: [0, 12],
-        pages: ['data on page 0', 'data on page 12'],
-      },
-      status: 'success',
-    })
-  })
-})

package/src/__tests__/inject-is-fetching.test.ts

@@ -1,35 +0,0 @@
-import { TestBed, fakeAsync, flush, tick } from '@angular/core/testing'
-import { QueryClient } from '@tanstack/query-core'
-import { beforeEach, describe, expect } from 'vitest'
-import { injectIsFetching } from '../inject-is-fetching'
-import { injectQuery } from '../inject-query'
-import { provideAngularQuery } from '../providers'
-import { delayedFetcher } from './test-utils'
-
-describe('injectIsFetching', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  test('Returns number of fetching queries', fakeAsync(() => {
-    const isFetching = TestBed.runInInjectionContext(() => {
-      injectQuery(() => ({
-        queryKey: ['isFetching1'],
-        queryFn: delayedFetcher(100),
-      }))
-      return injectIsFetching()
-    })
-
-    tick()
-
-    expect(isFetching()).toStrictEqual(1)
-    flush()
-    expect(isFetching()).toStrictEqual(0)
-  }))
-})

package/src/__tests__/inject-is-mutating.test.ts

@@ -1,39 +0,0 @@
-import { QueryClient } from '@tanstack/query-core'
-import { beforeEach, describe } from 'vitest'
-import { TestBed, fakeAsync, tick } from '@angular/core/testing'
-import { injectIsMutating } from '../inject-is-mutating'
-import { injectMutation } from '../inject-mutation'
-import { provideAngularQuery } from '../providers'
-import { successMutator } from './test-utils'
-
-describe('injectIsMutating', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = new QueryClient()
-
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(queryClient)],
-    })
-  })
-
-  test('should properly return isMutating state', fakeAsync(() => {
-    TestBed.runInInjectionContext(() => {
-      const isMutating = injectIsMutating()
-      const mutation = injectMutation(() => ({
-        mutationKey: ['isMutating1'],
-        mutationFn: successMutator<{ par1: string }>,
-      }))
-
-      expect(isMutating()).toBe(0)
-
-      mutation.mutate({
-        par1: 'par1',
-      })
-
-      tick()
-
-      expect(isMutating()).toBe(1)
-    })
-  }))
-})

package/src/__tests__/inject-mutation-state.test-d.ts

@@ -1,22 +0,0 @@
-import { describe, expectTypeOf } from 'vitest'
-import { injectMutationState } from '../inject-mutation-state'
-import type { MutationState, MutationStatus } from '@tanstack/query-core'
-
-describe('injectMutationState', () => {
-  it('should default to QueryState', () => {
-    const result = injectMutationState(() => ({
-      filters: { status: 'pending' },
-    }))
-
-    expectTypeOf(result()).toEqualTypeOf<Array<MutationState>>()
-  })
-
-  it('should infer with select', () => {
-    const result = injectMutationState(() => ({
-      filters: { status: 'pending' },
-      select: (mutation) => mutation.state.status,
-    }))
-
-    expectTypeOf(result()).toEqualTypeOf<Array<MutationStatus>>()
-  })
-})