@tanstack/angular-query-experimental 5.34.1 → 5.35.0

package/build/esm2022/inject-query.mjs

@@ -3,11 +3,44 @@ import { runInInjectionContext } from '@angular/core';
 import { assertInjector } from './util/assert-injector/assert-injector';
 import { injectQueryClient } from './inject-query-client';
 import { createBaseQuery } from './create-base-query';
-export function injectQuery(options, injector) {
+/**
+ * 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 function injectQuery(optionsFn, injector) {
     const assertedInjector = assertInjector(injectQuery, injector);
     return assertInjector(injectQuery, injector, () => {
         const queryClient = injectQueryClient();
-        return createBaseQuery((client) => runInInjectionContext(assertedInjector, () => options(client)), QueryObserver, queryClient);
+        return createBaseQuery((client) => runInInjectionContext(assertedInjector, () => optionsFn(client)), QueryObserver, queryClient);
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inject-query.js","sourceRoot":"","sources":["../../src/inject-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAoJrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,WAAW,CACzB,SAAsD,EACtD,QAAmB;IAEnB,MAAM,gBAAgB,GAAG,cAAc,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAA;IAC9D,OAAO,cAAc,CAAC,WAAW,EAAE,QAAQ,EAAE,GAAG,EAAE;QAChD,MAAM,WAAW,GAAG,iBAAiB,EAAE,CAAA;QACvC,OAAO,eAAe,CACpB,CAAC,MAAM,EAAE,EAAE,CACT,qBAAqB,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAClE,aAAa,EACb,WAAW,CACZ,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC","sourcesContent":["import { QueryObserver } from '@tanstack/query-core'\nimport { runInInjectionContext } from '@angular/core'\nimport { assertInjector } from './util/assert-injector/assert-injector'\nimport { injectQueryClient } from './inject-query-client'\nimport { createBaseQuery } from './create-base-query'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { Injector } from '@angular/core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataOptions,\n  UndefinedInitialDataOptions,\n} from './query-options'\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * **The options function can utilize signals**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param optionsFn - A function that returns query options.\n * @param injector - The Angular injector to use.\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  optionsFn: (\n    client: QueryClient,\n  ) => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n  injector?: Injector,\n): DefinedCreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * **The options function can utilize signals**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param optionsFn - A function that returns query options.\n * @param injector - The Angular injector to use.\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  optionsFn: (\n    client: QueryClient,\n  ) => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n  injector?: Injector,\n): CreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * **The options function can utilize signals**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param optionsFn - A function that returns query options.\n * @param injector - The Angular injector to use.\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  optionsFn: (\n    client: QueryClient,\n  ) => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  injector?: Injector,\n): CreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * **The options function can utilize signals**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param optionsFn - A function that returns query options.\n * @param injector - The Angular injector to use.\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery(\n  optionsFn: (client: QueryClient) => CreateQueryOptions,\n  injector?: Injector,\n) {\n  const assertedInjector = assertInjector(injectQuery, injector)\n  return assertInjector(injectQuery, injector, () => {\n    const queryClient = injectQueryClient()\n    return createBaseQuery(\n      (client) =>\n        runInInjectionContext(assertedInjector, () => optionsFn(client)),\n      QueryObserver,\n      queryClient,\n    )\n  })\n}\n"]}

package/build/esm2022/providers.mjs

@@ -1,5 +1,44 @@
 import { DestroyRef, ENVIRONMENT_INITIALIZER, inject, makeEnvironmentProviders, } from '@angular/core';
 import { provideQueryClient } from './inject-query-client';
+/**
+ * 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 function provideAngularQuery(queryClient) {
     return makeEnvironmentProviders([
         provideQueryClient(queryClient),
@@ -14,4 +53,4 @@ export function provideAngularQuery(queryClient) {
         },
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3ZpZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsVUFBVSxFQUNWLHVCQUF1QixFQUN2QixNQUFNLEVBQ04sd0JBQXdCLEdBQ3pCLE1BQU0sZUFBZSxDQUFBO0FBQ3RCLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHVCQUF1QixDQUFBO0FBSTFELE1BQU0sVUFBVSxtQkFBbUIsQ0FDakMsV0FBd0I7SUFFeEIsT0FBTyx3QkFBd0IsQ0FBQztRQUM5QixrQkFBa0IsQ0FBQyxXQUFXLENBQUM7UUFDL0I7WUFDRSxPQUFPLEVBQUUsdUJBQXVCO1lBQ2hDLEtBQUssRUFBRSxJQUFJO1lBQ1gsUUFBUSxFQUFFLEdBQUcsRUFBRTtnQkFDYixXQUFXLENBQUMsS0FBSyxFQUFFLENBQUE7Z0JBQ25CLGtEQUFrRDtnQkFDbEQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQTtZQUMzRCxDQUFDO1NBQ0Y7S0FDRixDQUFDLENBQUE7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRGVzdHJveVJlZixcbiAgRU5WSVJPTk1FTlRfSU5JVElBTElaRVIsXG4gIGluamVjdCxcbiAgbWFrZUVudmlyb25tZW50UHJvdmlkZXJzLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgcHJvdmlkZVF1ZXJ5Q2xpZW50IH0gZnJvbSAnLi9pbmplY3QtcXVlcnktY2xpZW50J1xuaW1wb3J0IHR5cGUgeyBFbnZpcm9ubWVudFByb3ZpZGVycyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgdHlwZSB7IFF1ZXJ5Q2xpZW50IH0gZnJvbSAnQHRhbnN0YWNrL3F1ZXJ5LWNvcmUnXG5cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlQW5ndWxhclF1ZXJ5KFxuICBxdWVyeUNsaWVudDogUXVlcnlDbGllbnQsXG4pOiBFbnZpcm9ubWVudFByb3ZpZGVycyB7XG4gIHJldHVybiBtYWtlRW52aXJvbm1lbnRQcm92aWRlcnMoW1xuICAgIHByb3ZpZGVRdWVyeUNsaWVudChxdWVyeUNsaWVudCksXG4gICAge1xuICAgICAgcHJvdmlkZTogRU5WSVJPTk1FTlRfSU5JVElBTElaRVIsXG4gICAgICBtdWx0aTogdHJ1ZSxcbiAgICAgIHVzZVZhbHVlOiAoKSA9PiB7XG4gICAgICAgIHF1ZXJ5Q2xpZW50Lm1vdW50KClcbiAgICAgICAgLy8gVW5tb3VudCB0aGUgcXVlcnkgY2xpZW50IG9uIGFwcGxpY2F0aW9uIGRlc3Ryb3lcbiAgICAgICAgaW5qZWN0KERlc3Ryb3lSZWYpLm9uRGVzdHJveSgoKSA9PiBxdWVyeUNsaWVudC51bm1vdW50KCkpXG4gICAgICB9LFxuICAgIH0sXG4gIF0pXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/esm2022/query-options.mjs

@@ -1,4 +1,26 @@
+/**
+ * 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 function queryOptions(options) {
     return options;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/esm2022/signal-proxy.mjs

@@ -1,11 +1,9 @@
 import { computed, untracked } from '@angular/core';
 /**
  * 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 function signalProxy(inputSignal) {
     const internalState = {};
@@ -37,4 +35,4 @@ export function signalProxy(inputSignal) {
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/esm2022/types.mjs

@@ -1,3 +1,3 @@
 /* istanbul ignore file */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,0BAA0B","sourcesContent":["/* istanbul ignore file */\n\nimport type {\n  DefaultError,\n  DefinedInfiniteQueryObserverResult,\n  DefinedQueryObserverResult,\n  InfiniteQueryObserverOptions,\n  InfiniteQueryObserverResult,\n  MutateFunction,\n  MutationObserverOptions,\n  MutationObserverResult,\n  OmitKeyof,\n  QueryKey,\n  QueryObserverOptions,\n  QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { MapToSignals } from './signal-proxy'\n\nexport interface CreateBaseQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  > {}\n\nexport interface CreateQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n    CreateBaseQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryFnData,\n      TQueryKey\n    >,\n    'suspense'\n  > {}\n\ntype CreateStatusBasedQueryResult<\n  TStatus extends QueryObserverResult['status'],\n  TData = unknown,\n  TError = DefaultError,\n> = Extract<QueryObserverResult<TData, TError>, { status: TStatus }>\n\nexport interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {\n  isSuccess: (\n    this: CreateBaseQueryResult<TData, TError>,\n  ) => this is CreateBaseQueryResult<\n    TData,\n    TError,\n    CreateStatusBasedQueryResult<'success', TData, TError>\n  >\n  isError: (\n    this: CreateBaseQueryResult<TData, TError>,\n  ) => this is CreateBaseQueryResult<\n    TData,\n    TError,\n    CreateStatusBasedQueryResult<'error', TData, TError>\n  >\n  isPending: (\n    this: CreateBaseQueryResult<TData, TError>,\n  ) => this is CreateBaseQueryResult<\n    TData,\n    TError,\n    CreateStatusBasedQueryResult<'pending', TData, TError>\n  >\n}\n\nexport interface CreateInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends OmitKeyof<\n    InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n    'suspense'\n  > {}\n\nexport type CreateBaseQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TState = QueryObserverResult<TData, TError>,\n> = BaseQueryNarrowing<TData, TError> &\n  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>\n\nexport type CreateQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n> = CreateBaseQueryResult<TData, TError>\n\nexport type DefinedCreateQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>,\n> = MapToSignals<TDefinedQueryObserver>\n\nexport type CreateInfiniteQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>\n\nexport type DefinedCreateInfiniteQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<\n    TData,\n    TError\n  >,\n> = MapToSignals<TDefinedInfiniteQueryObserver>\n\nexport interface CreateMutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> extends OmitKeyof<\n    MutationObserverOptions<TData, TError, TVariables, TContext>,\n    '_defaulted'\n  > {}\n\nexport type CreateMutateFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> = (\n  ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>\n) => void\n\nexport type CreateMutateAsyncFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> = MutateFunction<TData, TError, TVariables, TContext>\n\nexport type CreateBaseMutationResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n> = Override<\n  MutationObserverResult<TData, TError, TVariables, TContext>,\n  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }\n> & {\n  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>\n}\n\ntype CreateStatusBasedMutationResult<\n  TStatus extends CreateBaseMutationResult['status'],\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n> = Extract<\n  CreateBaseMutationResult<TData, TError, TVariables, TContext>,\n  { status: TStatus }\n>\n\nexport interface BaseMutationNarrowing<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n> {\n  isSuccess: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<\n      'success',\n      TData,\n      TError,\n      TVariables,\n      TContext\n    >\n  >\n  isError: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<\n      'error',\n      TData,\n      TError,\n      TVariables,\n      TContext\n    >\n  >\n  isPending: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<\n      'pending',\n      TData,\n      TError,\n      TVariables,\n      TContext\n    >\n  >\n  isIdle: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TContext>\n  >\n}\n\nexport type CreateMutationResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n  TState = CreateStatusBasedMutationResult<\n    CreateBaseMutationResult['status'],\n    TData,\n    TError,\n    TVariables,\n    TContext\n  >,\n> = BaseMutationNarrowing<TData, TError, TVariables, TContext> &\n  MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>\n\ntype Override<TTargetA, TTargetB> = {\n  [AKey in keyof TTargetA]: AKey extends keyof TTargetB\n    ? TTargetB[AKey]\n    : TTargetA[AKey]\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,0BAA0B","sourcesContent":["/* istanbul ignore file */\n\nimport type {\n  DefaultError,\n  DefinedInfiniteQueryObserverResult,\n  DefinedQueryObserverResult,\n  InfiniteQueryObserverOptions,\n  InfiniteQueryObserverResult,\n  MutateFunction,\n  MutationObserverOptions,\n  MutationObserverResult,\n  OmitKeyof,\n  QueryKey,\n  QueryObserverOptions,\n  QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { MapToSignals } from './signal-proxy'\n\n/**\n * @public\n */\nexport interface CreateBaseQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  > {}\n\n/**\n * @public\n */\nexport interface CreateQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n    CreateBaseQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryFnData,\n      TQueryKey\n    >,\n    'suspense'\n  > {}\n\n/**\n * @public\n */\ntype CreateStatusBasedQueryResult<\n  TStatus extends QueryObserverResult['status'],\n  TData = unknown,\n  TError = DefaultError,\n> = Extract<QueryObserverResult<TData, TError>, { status: TStatus }>\n\n/**\n * @public\n */\nexport interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {\n  isSuccess: (\n    this: CreateBaseQueryResult<TData, TError>,\n  ) => this is CreateBaseQueryResult<\n    TData,\n    TError,\n    CreateStatusBasedQueryResult<'success', TData, TError>\n  >\n  isError: (\n    this: CreateBaseQueryResult<TData, TError>,\n  ) => this is CreateBaseQueryResult<\n    TData,\n    TError,\n    CreateStatusBasedQueryResult<'error', TData, TError>\n  >\n  isPending: (\n    this: CreateBaseQueryResult<TData, TError>,\n  ) => this is CreateBaseQueryResult<\n    TData,\n    TError,\n    CreateStatusBasedQueryResult<'pending', TData, TError>\n  >\n}\n\n/**\n * @public\n */\nexport interface CreateInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends OmitKeyof<\n    InfiniteQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey,\n      TPageParam\n    >,\n    'suspense'\n  > {}\n\n/**\n * @public\n */\nexport type CreateBaseQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TState = QueryObserverResult<TData, TError>,\n> = BaseQueryNarrowing<TData, TError> &\n  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>\n\n/**\n * @public\n */\nexport type CreateQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n> = CreateBaseQueryResult<TData, TError>\n\n/**\n * @public\n */\nexport type DefinedCreateQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>,\n> = MapToSignals<TDefinedQueryObserver>\n\n/**\n * @public\n */\nexport type CreateInfiniteQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>\n\n/**\n * @public\n */\nexport type DefinedCreateInfiniteQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<\n    TData,\n    TError\n  >,\n> = MapToSignals<TDefinedInfiniteQueryObserver>\n\n/**\n * @public\n */\nexport interface CreateMutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> extends OmitKeyof<\n    MutationObserverOptions<TData, TError, TVariables, TContext>,\n    '_defaulted'\n  > {}\n\n/**\n * @public\n */\nexport type CreateMutateFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> = (\n  ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>\n) => void\n\n/**\n * @public\n */\nexport type CreateMutateAsyncFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> = MutateFunction<TData, TError, TVariables, TContext>\n\n/**\n * @public\n */\nexport type CreateBaseMutationResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n> = Override<\n  MutationObserverResult<TData, TError, TVariables, TContext>,\n  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }\n> & {\n  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>\n}\n\n/**\n * @public\n */\ntype CreateStatusBasedMutationResult<\n  TStatus extends CreateBaseMutationResult['status'],\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n> = Extract<\n  CreateBaseMutationResult<TData, TError, TVariables, TContext>,\n  { status: TStatus }\n>\n\n/**\n * @public\n */\nexport interface BaseMutationNarrowing<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n> {\n  isSuccess: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<\n      'success',\n      TData,\n      TError,\n      TVariables,\n      TContext\n    >\n  >\n  isError: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<\n      'error',\n      TData,\n      TError,\n      TVariables,\n      TContext\n    >\n  >\n  isPending: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<\n      'pending',\n      TData,\n      TError,\n      TVariables,\n      TContext\n    >\n  >\n  isIdle: (\n    this: CreateMutationResult<TData, TError, TVariables, TContext>,\n  ) => this is CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext,\n    CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TContext>\n  >\n}\n\n/**\n * @public\n */\nexport type CreateMutationResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TContext = unknown,\n  TState = CreateStatusBasedMutationResult<\n    CreateBaseMutationResult['status'],\n    TData,\n    TError,\n    TVariables,\n    TContext\n  >,\n> = BaseMutationNarrowing<TData, TError, TVariables, TContext> &\n  MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>\n\ntype Override<TTargetA, TTargetB> = {\n  [AKey in keyof TTargetA]: AKey extends keyof TTargetB\n    ? TTargetB[AKey]\n    : TTargetA[AKey]\n}\n"]}

package/build/fesm2022/tanstack-angular-query-experimental.mjs

@@ -4,21 +4,49 @@ import { untracked, computed, inject, Injector, NgZone, runInInjectionContext, D
 
 /* istanbul ignore file */
 
+/**
+ * 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
+ */
 function queryOptions(options) {
     return options;
 }
 
+/**
+ * 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
+ */
 function infiniteQueryOptions(options) {
     return options;
 }
 
 /**
  * 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.
  */
 function signalProxy(inputSignal) {
     const internalState = {};
@@ -93,7 +121,7 @@ function lazyInit(initializer) {
 /**
  * Base implementation for `injectQuery` and `injectInfiniteQuery`.
  */
-function createBaseQuery(options, Observer, queryClient) {
+function createBaseQuery(optionsFn, Observer, queryClient) {
     const injector = inject(Injector);
     const ngZone = inject(NgZone);
     return lazyInit(() => {
@@ -106,7 +134,7 @@ function createBaseQuery(options, Observer, queryClient) {
              * are preserved and can keep being applied after signal changes
              */
             const defaultedOptionsSignal = computed(() => {
-                const defaultedOptions = queryClient.defaultQueryOptions(options(queryClient));
+                const defaultedOptions = queryClient.defaultQueryOptions(optionsFn(queryClient));
                 defaultedOptions._optimisticResults = 'optimistic';
                 return defaultedOptions;
             });
@@ -223,15 +251,52 @@ function createNoopInjectionToken(description, options) {
     ];
 }
 
-const [injectQueryClient, provideQueryClient, QUERY_CLIENT] = createNoopInjectionToken('QueryClientToken');
+const tokens = createNoopInjectionToken('QueryClientToken');
+/**
+ * Injects the `QueryClient` instance into the component or service.
+ *
+ * **Example**
+ * ```ts
+ * const queryClient = injectQueryClient();
+ * ```
+ * @returns The `QueryClient` instance.
+ * @public
+ */
+const injectQueryClient = tokens[0];
+/**
+ * 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
+ */
+const provideQueryClient = tokens[1];
 
-function injectInfiniteQuery(options, injector) {
+/**
+ * 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
+ */
+function injectInfiniteQuery(optionsFn, injector) {
     return assertInjector(injectInfiniteQuery, injector, () => {
         const queryClient = injectQueryClient();
-        return createBaseQuery(options, InfiniteQueryObserver, queryClient);
+        return createBaseQuery(optionsFn, InfiniteQueryObserver, queryClient);
     });
 }
 
+/**
+ * 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
+ */
 function injectIsFetching(filters, injector) {
     return assertInjector(injectIsFetching, injector, () => {
         const queryClient = injectQueryClient();
@@ -256,6 +321,15 @@ function injectIsFetching(filters, injector) {
     });
 }
 
+/**
+ * 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
+ */
 function injectIsMutating(filters, injector) {
     return assertInjector(injectIsMutating, injector, () => {
         const queryClient = injectQueryClient();
@@ -280,19 +354,28 @@ function injectIsMutating(filters, injector) {
     });
 }
 
-function injectMutation(options, injector) {
+/**
+ * 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
+ */
+function injectMutation(optionsFn, injector) {
     return assertInjector(injectMutation, injector, () => {
         const queryClient = injectQueryClient();
         const currentInjector = inject(Injector);
         const destroyRef = inject(DestroyRef);
         const ngZone = inject(NgZone);
         return lazyInit(() => runInInjectionContext(currentInjector, () => {
-            const observer = new MutationObserver(queryClient, options(queryClient));
+            const observer = new MutationObserver(queryClient, optionsFn(queryClient));
             const mutate = (variables, mutateOptions) => {
                 observer.mutate(variables, mutateOptions).catch(noop);
             };
             effect(() => {
-                observer.setOptions(options(queryClient));
+                observer.setOptions(optionsFn(queryClient));
             });
             const result = signal(observer.getCurrentResult());
             const unsubscribe = observer.subscribe(notifyManager.batchCalls((state) => {
@@ -335,6 +418,13 @@ function getResult(mutationCache, options) {
         ? options.select(mutation)
         : mutation.state));
 }
+/**
+ * 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
+ */
 function injectMutationState(mutationStateOptionsFn = () => ({}), options) {
     return assertInjector(injectMutationState, options?.injector, () => {
         const destroyRef = inject(DestroyRef);
@@ -365,6 +455,9 @@ function injectMutationState(mutationStateOptionsFn = () => ({}), options) {
     });
 }
 
+/**
+ * @public
+ */
 function injectQueries({ queries, ...options }, injector) {
     return assertInjector(injectQueries, injector, () => {
         const queryClient = injectQueryClient();
@@ -391,14 +484,86 @@ function injectQueries({ queries, ...options }, injector) {
     });
 }
 
-function injectQuery(options, injector) {
+/**
+ * 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
+ */
+function injectQuery(optionsFn, injector) {
     const assertedInjector = assertInjector(injectQuery, injector);
     return assertInjector(injectQuery, injector, () => {
         const queryClient = injectQueryClient();
-        return createBaseQuery((client) => runInInjectionContext(assertedInjector, () => options(client)), QueryObserver, queryClient);
+        return createBaseQuery((client) => runInInjectionContext(assertedInjector, () => optionsFn(client)), QueryObserver, queryClient);
     });
 }
 
+/**
+ * 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
+ */
 function provideAngularQuery(queryClient) {
     return makeEnvironmentProviders([
         provideQueryClient(queryClient),
@@ -421,5 +586,5 @@ function provideAngularQuery(queryClient) {
  * Generated bundle index. Do not edit.
  */
 
-export { QUERY_CLIENT, infiniteQueryOptions, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectMutation, injectMutationState, injectQueries, injectQuery, injectQueryClient, provideAngularQuery, provideQueryClient, queryOptions };
+export { infiniteQueryOptions, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectMutation, injectMutationState, injectQueries, injectQuery, injectQueryClient, provideAngularQuery, provideQueryClient, queryOptions };
 //# sourceMappingURL=tanstack-angular-query-experimental.mjs.map