@tanstack/angular-query-experimental 5.34.2 → 5.35.0

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

@@ -1,34 +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>>);
-};
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-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>>;
-};
-/**
- * Allows to share and re-use infinite query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- * @param options - The infinite query options to tag with the type from `queryFn`.
- * @returns The tagged infinite query options.
- * @public
- */
-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,31 +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';
-/**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param optionsFn - A function that returns infinite query options.
- * @param injector - The Angular injector to use.
- * @returns The infinite query result.
- * @public
- */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(optionsFn: (client: QueryClient) => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, injector?: Injector): CreateInfiniteQueryResult<TData, TError>;
-/**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param optionsFn - A function that returns infinite query options.
- * @param injector - The Angular injector to use.
- * @returns The infinite query result.
- * @public
- */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(optionsFn: (client: QueryClient) => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, injector?: Injector): DefinedCreateInfiniteQueryResult<TData, TError>;
-/**
- * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
- * @param optionsFn - A function that returns infinite query options.
- * @param injector - The Angular injector to use.
- * @returns The infinite query result.
- * @public
- */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(optionsFn: (client: QueryClient) => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, injector?: Injector): CreateInfiniteQueryResult<TData, TError>;

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

@@ -1,13 +0,0 @@
-import { type QueryFilters } from '@tanstack/query-core';
-import type { Injector, Signal } from '@angular/core';
-/**
- * Injects a signal that tracks the number of queries that your application is loading or
- * fetching in the background.
- *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
- * @param injector - The Angular injector to use.
- * @returns signal with number of loading or fetching queries.
- * @public
- */
-export declare function injectIsFetching(filters?: QueryFilters, injector?: Injector): Signal<number>;

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

@@ -1,12 +0,0 @@
-import { type MutationFilters } from '@tanstack/query-core';
-import type { Injector, Signal } from '@angular/core';
-/**
- * Injects a signal that tracks the number of mutations that your application is fetching.
- *
- * Can be used for app-wide loading indicators
- * @param filters - The filters to apply to the query.
- * @param injector - The Angular injector to use.
- * @returns signal with number of fetching mutations.
- * @public
- */
-export declare function injectIsMutating(filters?: MutationFilters, injector?: Injector): Signal<number>;

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

@@ -1,21 +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;
-};
-/**
- * @public
- */
-export interface InjectMutationStateOptions {
-    injector?: Injector;
-}
-/**
- * Injects a signal that tracks the state of all mutations.
- * @param mutationStateOptionsFn - A function that returns mutation state options.
- * @param options - The Angular injector to use.
- * @returns The signal that tracks the state of all mutations.
- * @public
- */
-export declare function injectMutationState<TResult = MutationState>(mutationStateOptionsFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
-export {};

package/build/inject-mutation.d.ts

@@ -1,13 +0,0 @@
-import { Injector } from '@angular/core';
-import type { DefaultError, QueryClient } from '@tanstack/query-core';
-import type { CreateMutationOptions, CreateMutationResult } from './types';
-/**
- * Injects a mutation: an imperative function that can be invoked which typically performs server side effects.
- *
- * Unlike queries, mutations are not run automatically.
- * @param optionsFn - A function that returns mutation options.
- * @param injector - The Angular injector to use.
- * @returns The mutation.
- * @public
- */
-export declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(optionsFn: (client: QueryClient) => CreateMutationOptions<TData, TError, TVariables, TContext>, injector?: Injector): CreateMutationResult<TData, TError, TVariables, TContext>;

package/build/inject-queries.d.ts

@@ -1,76 +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
- * @public
- */
-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
- * @public
- */
-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>;
-/**
- * @public
- */
-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,30 +0,0 @@
-import type { QueryClient } from '@tanstack/query-core';
-/**
- * Injects the `QueryClient` instance into the component or service.
- *
- * **Example**
- * ```ts
- * const queryClient = injectQueryClient();
- * ```
- * @returns The `QueryClient` instance.
- * @public
- */
-export 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;
-};
-/**
- * Usually {@link provideAngularQuery} is used once to set up TanStack Query and the
- * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}
- * for the entire application. You can use `provideQueryClient` to provide a
- * different `QueryClient` instance for a part of the application.
- * @public
- */
-export declare const provideQueryClient: ((value: QueryClient | (() => QueryClient)) => import("@angular/core").Provider) & ((value: QueryClient | (() => QueryClient)) => import("@angular/core").Provider);

package/build/inject-query.d.ts

@@ -1,106 +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';
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * **The options function can utilize signals**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: (client: QueryClient) => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): DefinedCreateQueryResult<TData, TError>;
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * **The options function can utilize signals**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: (client: QueryClient) => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * **The options function can utilize signals**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param optionsFn - A function that returns query options.
- * @param injector - The Angular injector to use.
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: (client: QueryClient) => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, injector?: Injector): CreateQueryResult<TData, TError>;

package/build/providers.d.ts

@@ -1,42 +0,0 @@
-import type { EnvironmentProviders } from '@angular/core';
-import type { QueryClient } from '@tanstack/query-core';
-/**
- * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
- *
- * Allows to configure a `QueryClient`.
- *
- * **Example - standalone**
- *
- * ```ts
- * import {
- *   provideAngularQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * bootstrapApplication(AppComponent, {
- *   providers: [provideAngularQuery(new QueryClient())],
- * })
- * ```
- *
- * **Example - NgModule-based**
- *
- * ```ts
- * import {
- *   provideAngularQuery,
- *   QueryClient,
- * } from '@tanstack/angular-query-experimental'
- *
- * @NgModule({
- *   declarations: [AppComponent],
- *   imports: [BrowserModule],
- *   providers: [provideAngularQuery(new QueryClient())],
- *   bootstrap: [AppComponent],
- * })
- * export class AppModule {}
- * ```
- * @param queryClient - A `QueryClient` instance.
- * @returns A set of providers to set up TanStack Query.
- * @public
- * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
- */
-export declare function provideAngularQuery(queryClient: QueryClient): EnvironmentProviders;

package/build/query-options.d.ts

@@ -1,66 +0,0 @@
-import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core';
-import type { CreateQueryOptions } from './types';
-/**
- * @public
- */
-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;
-/**
- * @public
- */
-export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
-};
-/**
- * Allows to share and re-use query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- *
- * **Example**
- *
- * ```ts
- *  const { queryKey } = queryOptions({
- *     queryKey: ['key'],
- *     queryFn: () => Promise.resolve(5),
- *     //  ^?  Promise<number>
- *   })
- *
- *   const queryClient = new QueryClient()
- *   const data = queryClient.getQueryData(queryKey)
- *   //    ^?  number | undefined
- * ```
- * @param options - The query options to tag with the type from `queryFn`.
- * @returns The tagged query options.
- * @public
- */
-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>;
-};
-/**
- * Allows to share and re-use query options in a type-safe way.
- *
- * The `queryKey` will be tagged with the type from `queryFn`.
- *
- * **Example**
- *
- * ```ts
- *  const { queryKey } = queryOptions({
- *     queryKey: ['key'],
- *     queryFn: () => Promise.resolve(5),
- *     //  ^?  Promise<number>
- *   })
- *
- *   const queryClient = new QueryClient()
- *   const data = queryClient.getQueryData(queryKey)
- *   //    ^?  number | undefined
- * ```
- * @param options - The query options to tag with the type from `queryFn`.
- * @returns The tagged query options.
- * @public
- */
-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,11 +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.
- * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
- */
-export declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;

package/build/types.d.ts

@@ -1,95 +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';
-/**
- * @public
- */
-export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-}
-/**
- * @public
- */
-export interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
-}
-/**
- * @public
- */
-type CreateStatusBasedQueryResult<TStatus extends QueryObserverResult['status'], TData = unknown, TError = DefaultError> = Extract<QueryObserverResult<TData, TError>, {
-    status: TStatus;
-}>;
-/**
- * @public
- */
-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>>;
-}
-/**
- * @public
- */
-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'> {
-}
-/**
- * @public
- */
-export type CreateBaseQueryResult<TData = unknown, TError = DefaultError, TState = QueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
-/**
- * @public
- */
-export type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
-/**
- * @public
- */
-export type DefinedCreateQueryResult<TData = unknown, TError = DefaultError, TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>> = MapToSignals<TDefinedQueryObserver>;
-/**
- * @public
- */
-export type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>;
-/**
- * @public
- */
-export type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError, TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<TData, TError>> = MapToSignals<TDefinedInfiniteQueryObserver>;
-/**
- * @public
- */
-export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
-}
-/**
- * @public
- */
-export type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-/**
- * @public
- */
-export type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-/**
- * @public
- */
-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>;
-};
-/**
- * @public
- */
-type CreateStatusBasedMutationResult<TStatus extends CreateBaseMutationResult['status'], TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Extract<CreateBaseMutationResult<TData, TError, TVariables, TContext>, {
-    status: TStatus;
-}>;
-/**
- * @public
- */
-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>>;
-}
-/**
- * @public
- */
-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;