@tanstack/angular-query-experimental 5.103.2 → 5.104.0

package/dist/providers.mjs

@@ -0,0 +1,124 @@
+import { DestroyRef, InjectionToken, inject } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/providers.ts
+/**
+* Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the
+* [`QueryClient`](https://tanstack.com/query/latest/docs/reference/QueryClient) for the entire application —
+* it calls `provideQueryClient` internally. Use `provideQueryClient` directly to provide a different
+* `QueryClient` instance for part of the application, or for unit testing.
+* @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
+* @returns A provider object that can be used to provide the `QueryClient` instance.
+*
+* @example
+* Providing a test-only `QueryClient` in a component test, without wiring up `provideTanStackQuery`'s other
+* defaults:
+* ```ts
+* TestBed.configureTestingModule({
+*   providers: [provideQueryClient(new QueryClient())],
+* })
+* ```
+*/
+function provideQueryClient(queryClient) {
+	return {
+		provide: QueryClient,
+		useFactory: () => {
+			const client = queryClient instanceof InjectionToken ? inject(queryClient) : queryClient;
+			inject(DestroyRef).onDestroy(() => client.unmount());
+			client.mount();
+			return client;
+		}
+	};
+}
+/**
+* Sets up providers necessary to enable TanStack Query functionality for Angular applications. Allows
+* configuring a `QueryClient` and optional features such as developer tools.
+*
+* @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
+* @see {@link withDevtools}
+* @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
+* @param features - Optional features to configure additional Query functionality.
+* @returns A set of providers to set up TanStack Query.
+*
+* @example
+* ```ts
+* import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'
+*
+* bootstrapApplication(AppComponent, {
+*   providers: [provideTanStackQuery(new QueryClient())],
+* })
+* ```
+*
+* @example
+* The same, in an `NgModule`-based application:
+* ```ts
+* import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'
+*
+* @NgModule({
+*   declarations: [AppComponent],
+*   imports: [BrowserModule],
+*   providers: [provideTanStackQuery(new QueryClient())],
+*   bootstrap: [AppComponent],
+* })
+* export class AppModule {}
+* ```
+*
+* @example
+* Enabling optional developer tools by adding `withDevtools` — by default, the tools are then loaded when
+* your app is in development mode:
+* ```ts
+* import {
+*   provideTanStackQuery,
+*   withDevtools,
+*   QueryClient,
+* } from '@tanstack/angular-query-experimental'
+*
+* bootstrapApplication(AppComponent, {
+*   providers: [provideTanStackQuery(new QueryClient(), withDevtools())],
+* })
+* ```
+*
+* @example
+* Using an `InjectionToken` for the `QueryClient` — an advanced optimization that lets TanStack Query be
+* absent from the main application bundle, useful for including it on lazy-loaded routes only while still
+* sharing a `QueryClient`. This is a small optimization; for most applications it's preferable to provide
+* the `QueryClient` in the main application config, as in the examples above:
+* ```ts
+* export const MY_QUERY_CLIENT = new InjectionToken('', {
+*   factory: () => new QueryClient(),
+* })
+*
+* // In a lazy loaded route or lazy loaded component's providers array:
+* providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
+* ```
+*/
+function provideTanStackQuery(queryClient, ...features) {
+	return [provideQueryClient(queryClient), features.map((feature) => feature.ɵproviders)];
+}
+/**
+* Sets up providers necessary to enable TanStack Query functionality for Angular applications.
+*
+* Allows configuring a `QueryClient`.
+* @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
+* @param queryClient - A `QueryClient` instance.
+* @returns A set of providers to set up TanStack Query.
+* @deprecated Use `provideTanStackQuery` instead.
+*/
+function provideAngularQuery(queryClient) {
+	return provideTanStackQuery(queryClient);
+}
+/**
+* Helper function to create an object that represents a Query feature.
+* @param kind - The kind of feature, e.g. `'Devtools'`.
+* @param providers - The Angular providers this feature contributes to `provideTanStackQuery`.
+* @returns A Query feature.
+*/
+function queryFeature(kind, providers) {
+	return {
+		ɵkind: kind,
+		ɵproviders: providers
+	};
+}
+//#endregion
+export { provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeature };
+
+//# sourceMappingURL=providers.mjs.map

package/dist/providers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.mjs","names":[],"sources":["../src/providers.ts"],"sourcesContent":["import { DestroyRef, InjectionToken, inject } from '@angular/core'\nimport { QueryClient } from '@tanstack/query-core'\nimport type { Provider } from '@angular/core'\n\n/**\n * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the\n * [`QueryClient`](https://tanstack.com/query/latest/docs/reference/QueryClient) for the entire application —\n * it calls `provideQueryClient` internally. Use `provideQueryClient` directly to provide a different\n * `QueryClient` instance for part of the application, or for unit testing.\n * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.\n * @returns A provider object that can be used to provide the `QueryClient` instance.\n *\n * @example\n * Providing a test-only `QueryClient` in a component test, without wiring up `provideTanStackQuery`'s other\n * defaults:\n * ```ts\n * TestBed.configureTestingModule({\n *   providers: [provideQueryClient(new QueryClient())],\n * })\n * ```\n */\nexport function provideQueryClient(\n  queryClient: QueryClient | InjectionToken<QueryClient>,\n): Provider {\n  return {\n    provide: QueryClient,\n    useFactory: () => {\n      const client =\n        queryClient instanceof InjectionToken\n          ? inject(queryClient)\n          : queryClient\n      // Unmount the query client on injector destroy\n      inject(DestroyRef).onDestroy(() => client.unmount())\n      client.mount()\n      return client\n    },\n  }\n}\n\n/**\n * Sets up providers necessary to enable TanStack Query functionality for Angular applications. Allows\n * configuring a `QueryClient` and optional features such as developer tools.\n *\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @see {@link withDevtools}\n * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.\n * @param features - Optional features to configure additional Query functionality.\n * @returns A set of providers to set up TanStack Query.\n *\n * @example\n * ```ts\n * import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [provideTanStackQuery(new QueryClient())],\n * })\n * ```\n *\n * @example\n * The same, in an `NgModule`-based application:\n * ```ts\n * import { provideTanStackQuery, QueryClient } from '@tanstack/angular-query-experimental'\n *\n * @NgModule({\n *   declarations: [AppComponent],\n *   imports: [BrowserModule],\n *   providers: [provideTanStackQuery(new QueryClient())],\n *   bootstrap: [AppComponent],\n * })\n * export class AppModule {}\n * ```\n *\n * @example\n * Enabling optional developer tools by adding `withDevtools` — by default, the tools are then loaded when\n * your app is in development mode:\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   withDevtools,\n *   QueryClient,\n * } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [provideTanStackQuery(new QueryClient(), withDevtools())],\n * })\n * ```\n *\n * @example\n * Using an `InjectionToken` for the `QueryClient` — an advanced optimization that lets TanStack Query be\n * absent from the main application bundle, useful for including it on lazy-loaded routes only while still\n * sharing a `QueryClient`. This is a small optimization; for most applications it's preferable to provide\n * the `QueryClient` in the main application config, as in the examples above:\n * ```ts\n * export const MY_QUERY_CLIENT = new InjectionToken('', {\n *   factory: () => new QueryClient(),\n * })\n *\n * // In a lazy loaded route or lazy loaded component's providers array:\n * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]\n * ```\n */\nexport function provideTanStackQuery(\n  queryClient: QueryClient | InjectionToken<QueryClient>,\n  ...features: Array<QueryFeatures>\n): Array<Provider> {\n  return [\n    provideQueryClient(queryClient),\n    features.map((feature) => feature.ɵproviders),\n  ]\n}\n\n/**\n * Sets up providers necessary to enable TanStack Query functionality for Angular applications.\n *\n * Allows configuring a `QueryClient`.\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @param queryClient - A `QueryClient` instance.\n * @returns A set of providers to set up TanStack Query.\n * @deprecated Use `provideTanStackQuery` instead.\n */\nexport function provideAngularQuery(queryClient: QueryClient): Array<Provider> {\n  return provideTanStackQuery(queryClient)\n}\n\nconst queryFeatures = ['Devtools', 'PersistQueryClient'] as const\n\ntype QueryFeatureKind = (typeof queryFeatures)[number]\n\n/**\n * Helper type to represent a Query feature.\n */\nexport interface QueryFeature<TFeatureKind extends QueryFeatureKind> {\n  ɵkind: TFeatureKind\n  ɵproviders: Array<Provider>\n}\n\n/**\n * Helper function to create an object that represents a Query feature.\n * @param kind - The kind of feature, e.g. `'Devtools'`.\n * @param providers - The Angular providers this feature contributes to `provideTanStackQuery`.\n * @returns A Query feature.\n */\nexport function queryFeature<TFeatureKind extends QueryFeatureKind>(\n  kind: TFeatureKind,\n  providers: Array<Provider>,\n): QueryFeature<TFeatureKind> {\n  return { ɵkind: kind, ɵproviders: providers }\n}\n\n/**\n * A type alias that represents a feature which enables developer tools.\n * The type is used to describe the return value of the `withDevtools` function.\n * @see {@link withDevtools}\n */\nexport type DevtoolsFeature = QueryFeature<'Devtools'>\n\n/**\n * A type alias that represents a feature which enables persistence.\n * The type is used to describe the return value of the `withPersistQueryClient` function.\n */\nexport type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>\n\n/**\n * A type alias that represents all Query features available for use with `provideTanStackQuery`.\n * Features can be enabled by adding special functions to the `provideTanStackQuery` call.\n * See documentation for each symbol to find corresponding function name. See also `provideTanStackQuery`\n * documentation on how to use those functions.\n * @see {@link provideTanStackQuery}\n */\nexport type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,mBACd,aACU;CACV,OAAO;EACL,SAAS;EACT,kBAAkB;GAChB,MAAM,SACJ,uBAAuB,iBACnB,OAAO,WAAW,IAClB;GAEN,OAAO,UAAU,CAAC,CAAC,gBAAgB,OAAO,QAAQ,CAAC;GACnD,OAAO,MAAM;GACb,OAAO;EACT;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,SAAgB,qBACd,aACA,GAAG,UACc;CACjB,OAAO,CACL,mBAAmB,WAAW,GAC9B,SAAS,KAAK,YAAY,QAAQ,UAAU,CAC9C;AACF;;;;;;;;;;AAWA,SAAgB,oBAAoB,aAA2C;CAC7E,OAAO,qBAAqB,WAAW;AACzC;;;;;;;AAoBA,SAAgB,aACd,MACA,WAC4B;CAC5B,OAAO;EAAE,OAAO;EAAM,YAAY;CAAU;AAC9C"}

package/{query-options.d.ts → dist/query-options.d.mts}

@@ -1,5 +1,6 @@
-import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, QueryKeyWithDataTag, SkipToken } from '@tanstack/query-core';
-import { CreateQueryOptions } from './types.js';
+import { CreateQueryOptions } from "./types.mjs";
+import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
+//#region src/query-options.d.ts
 /**
  * The options accepted by the `queryOptions` overload selected when no `initialData` is set — `data` may be
  * `undefined` while the query is `pending`.
@@ -10,14 +11,14 @@ import { CreateQueryOptions } from './types.js';
  * @template TQueryKey - The type of your `queryKey`.
  */
 export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    /**
-     * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
-     * created or cached yet). If set to a function, the function will be called **once** during the shared/root
-     * query initialization, and be expected to synchronously return the initial data. Initial data is
-     * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the
-     * cache.
-     */
-    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
+  /**
+   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
+   * created or cached yet). If set to a function, the function will be called **once** during the shared/root
+   * query initialization, and be expected to synchronously return the initial data. Initial data is
+   * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the
+   * cache.
+   */
+  initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
 };
 /**
  * The options accepted by the `queryOptions` overload selected when no `initialData` is set and `queryFn` is
@@ -29,13 +30,13 @@ export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = Default
  * @template TQueryKey - The type of your `queryKey`.
  */
 export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
-    /**
-     * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
-     * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
-     * fetch that fails with "Missing queryFn" unless `enabled` is `false` or a default query function has been
-     * defined. A default query function only supplies `queryFn`; it doesn't defer the fetch on its own.
-     */
-    queryFn?: Exclude<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken | undefined>;
+  /**
+   * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
+   * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
+   * fetch that fails with "Missing queryFn" unless `enabled` is `false` or a default query function has been
+   * defined. A default query function only supplies `queryFn`; it doesn't defer the fetch on its own.
+   */
+  queryFn?: Exclude<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken | undefined>;
 };
 /**
  * The options accepted by the `queryOptions` overload selected when `initialData` is set — `data` is never
@@ -47,20 +48,20 @@ export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError
  * @template TQueryKey - The type of your `queryKey`.
  */
 export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
-    /**
-     * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
-     * created or cached yet). If set to a function, the function will be called **once** during the shared/root
-     * query initialization, and be expected to synchronously return the initial data. Initial data is
-     * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the
-     * cache.
-     */
-    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
-    /**
-     * Optional here, but omitting it is only safe when no fetch will be attempted — for example with
-     * `enabled: false`, or when a default query function has been defined. Otherwise, an enabled query with no
-     * `queryFn` still tries to fetch and fails with a "Missing queryFn" error; `initialData` does not prevent this.
-     */
-    queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
+  /**
+   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
+   * created or cached yet). If set to a function, the function will be called **once** during the shared/root
+   * query initialization, and be expected to synchronously return the initial data. Initial data is
+   * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the
+   * cache.
+   */
+  initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+  /**
+   * Optional here, but omitting it is only safe when no fetch will be attempted — for example with
+   * `enabled: false`, or when a default query function has been defined. Otherwise, an enabled query with no
+   * `queryFn` still tries to fetch and fails with a "Missing queryFn" error; `initialData` does not prevent this.
+   */
+  queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
 };
 /**
  * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options
@@ -219,3 +220,5 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
  * ```
  */
 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> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
+//#endregion
+//# sourceMappingURL=query-options.d.mts.map

package/dist/query-options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.d.mts","names":[],"sources":["../src/query-options.ts"],"mappings":";;;;;;;;;;;;YAqBY,4BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAQlD,0BAEI,oBAAoB,kBAAkB,iBACtC,kBAAkB;;;;;;;;;;;YAYZ,uBACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;EAShD,UAAU,QACR,mBAAmB,cAAc,QAAQ,OAAO,uBAChD;;;;;;;;;;;YAaQ,0BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,KACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAUhD,aACE,kBAAkB,uBAAuB,kBAAkB;;;;;;EAM7D,UAAU,cAAc,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CxB,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,aAC/D,0BAA0B,cAAc,QAAQ,OAAO,aACxD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyC/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,uBAAuB,cAAc,QAAQ,OAAO,aAC5D,uBAAuB,cAAc,QAAQ,OAAO,aACrD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,aACjE,4BAA4B,cAAc,QAAQ,OAAO,aAC1D,oBAAoB,WAAW,cAAc"}

package/dist/query-options.mjs

@@ -0,0 +1,8 @@
+//#region src/query-options.ts
+function queryOptions(options) {
+	return options;
+}
+//#endregion
+export { queryOptions };
+
+//# sourceMappingURL=query-options.mjs.map

package/dist/query-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.mjs","names":[],"sources":["../src/query-options.ts"],"sourcesContent":["import type {\n  DefaultError,\n  InitialDataFunction,\n  NonUndefinedGuard,\n  OmitKeyof,\n  QueryFunction,\n  QueryKey,\n  QueryKeyWithDataTag,\n  SkipToken,\n} from '@tanstack/query-core'\nimport type { CreateQueryOptions } from './types'\n\n/**\n * The options accepted by the `queryOptions` overload selected when no `initialData` is set — `data` may be\n * `undefined` while the query is `pending`.\n *\n * @template TQueryFnData - The type your `queryFn` resolves to.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TQueryKey - The type of your `queryKey`.\n */\nexport type UndefinedInitialDataOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n  /**\n   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been\n   * created or cached yet). If set to a function, the function will be called **once** during the shared/root\n   * query initialization, and be expected to synchronously return the initial data. Initial data is\n   * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the\n   * cache.\n   */\n  initialData?:\n    | undefined\n    | InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n    | NonUndefinedGuard<TQueryFnData>\n}\n\n/**\n * The options accepted by the `queryOptions` overload selected when no `initialData` is set and `queryFn` is\n * not `skipToken` — same as {@link UndefinedInitialDataOptions}, but `queryFn` may not be `skipToken`.\n *\n * @template TQueryFnData - The type your `queryFn` resolves to.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TQueryKey - The type of your `queryKey`.\n */\nexport type UnusedSkipTokenOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'queryFn'\n> & {\n  /**\n   * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If\n   * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a\n   * fetch that fails with \"Missing queryFn\" unless `enabled` is `false` or a default query function has been\n   * defined. A default query function only supplies `queryFn`; it doesn't defer the fetch on its own.\n   */\n  queryFn?: Exclude<\n    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n    SkipToken | undefined\n  >\n}\n\n/**\n * The options accepted by the `queryOptions` overload selected when `initialData` is set — `data` is never\n * `undefined` (unless a `select` changes `TData` to include `undefined`).\n *\n * @template TQueryFnData - The type your `queryFn` resolves to.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TQueryKey - The type of your `queryKey`.\n */\nexport type DefinedInitialDataOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = Omit<\n  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'queryFn'\n> & {\n  /**\n   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been\n   * created or cached yet). If set to a function, the function will be called **once** during the shared/root\n   * query initialization, and be expected to synchronously return the initial data. Initial data is\n   * considered stale by default unless a `staleTime` has been set. `initialData` **is persisted** to the\n   * cache.\n   */\n  initialData:\n    NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>)\n  /**\n   * Optional here, but omitting it is only safe when no fetch will be attempted — for example with\n   * `enabled: false`, or when a default query function has been defined. Otherwise, an enabled query with no\n   * `queryFn` still tries to fetch and fails with a \"Missing queryFn\" error; `initialData` does not prevent this.\n   */\n  queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\n/**\n * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options\n * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is\n * required and is the query key to generate options for.\n *\n * This overload is selected when `initialData` is set, so the resulting `data` is never `undefined` (unless\n * a `select` changes `TData` to include `undefined`).\n *\n * @see {@link injectQuery} to run a query with these options.\n * @see [The Query Options API](https://tkdodo.eu/blog/the-query-options-api) for more on this pattern.\n * @param options - The {@link DefinedInitialDataOptions} to use — everything you can pass to `injectQuery`,\n * with `initialData` set.\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n *\n * @example\n * ```angular-ts\n * import { queryOptions, injectQuery } from '@tanstack/angular-query-experimental'\n *\n * export const postsOptions = queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: fetchPosts,\n *   initialData: [],\n * })\n *\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <!-- `postsQuery.data()` is never `undefined`, thanks to `initialData` — even if a refetch\n *     fails, so the list stays visible alongside the error. -->\n *     @if (postsQuery.isError()) {\n *       <span>Error: {{ postsQuery.error()?.message }}</span>\n *     }\n *     <ul>\n *       @for (post of postsQuery.data(); track post.id) {\n *         <li>{{ post.title }}</li>\n *       }\n *     </ul>\n *   `,\n * })\n * export class Posts {\n *   readonly postsQuery = injectQuery(() => postsOptions)\n * }\n * ```\n */\nexport function queryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n  QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\n/**\n * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options\n * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is\n * required and is the query key to generate options for.\n *\n * @see {@link injectQuery} to run a query with these options.\n * @see [The Query Options API](https://tkdodo.eu/blog/the-query-options-api) for more on this pattern.\n * @param options - The {@link UnusedSkipTokenOptions} to use — everything you can pass to `injectQuery`.\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n *\n * @example\n * A parameterized factory, so the same options object can be reused per `id`:\n * ```angular-ts\n * import { queryOptions, injectQuery } from '@tanstack/angular-query-experimental'\n *\n * export const postOptions = (id: string) =>\n *   queryOptions({\n *     queryKey: ['post', id],\n *     queryFn: () => fetchPost(id),\n *   })\n *\n * @Component({\n *   selector: 'post',\n *   template: `\n *     @if (postQuery.isPending()) {\n *       Loading...\n *     } @else if (postQuery.isError()) {\n *       <span>Error: {{ postQuery.error()?.message }}</span>\n *     } @else {\n *       <h1>{{ postQuery.data().title }}</h1>\n *     }\n *   `,\n * })\n * export class Post {\n *   readonly id = signal('1')\n *   readonly postQuery = injectQuery(() => postOptions(this.id()))\n * }\n * ```\n */\nexport function queryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> &\n  QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\n/**\n * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options\n * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is\n * required and is the query key to generate options for.\n *\n * @see {@link injectQuery} to run a query with these options.\n * @see [The Query Options API](https://tkdodo.eu/blog/the-query-options-api) for more on this pattern.\n * @param options - The {@link UndefinedInitialDataOptions} to use — everything you can pass to `injectQuery`.\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks This is the only overload that accepts `queryFn: skipToken`, shown below.\n *\n * @example\n * A parameterized factory, so the same options object can be reused per `id`:\n * ```angular-ts\n * import { queryOptions, injectQuery } from '@tanstack/angular-query-experimental'\n *\n * export const postOptions = (id: string) =>\n *   queryOptions({\n *     queryKey: ['post', id],\n *     queryFn: () => fetchPost(id),\n *   })\n *\n * @Component({\n *   selector: 'post',\n *   template: `\n *     @if (postQuery.isPending()) {\n *       Loading...\n *     } @else if (postQuery.isError()) {\n *       <span>Error: {{ postQuery.error()?.message }}</span>\n *     } @else {\n *       <h1>{{ postQuery.data().title }}</h1>\n *     }\n *   `,\n * })\n * export class Post {\n *   readonly id = signal('1')\n *   readonly postQuery = injectQuery(() => postOptions(this.id()))\n * }\n * ```\n *\n * @example\n * A factory that disables the query, type safe, until `postId` is set:\n * ```angular-ts\n * import { queryOptions, skipToken, injectQuery } from '@tanstack/angular-query-experimental'\n *\n * export const postOptions = (postId: number | undefined) =>\n *   queryOptions({\n *     queryKey: ['post', postId],\n *     queryFn: postId != null ? () => fetchPost(postId) : skipToken,\n *   })\n *\n * @Component({\n *   selector: 'post',\n *   template: `\n *     @if (postId() == null) {\n *       Select a post\n *     } @else if (postQuery.isPending()) {\n *       Loading...\n *     } @else if (postQuery.isError()) {\n *       <span>Error: {{ postQuery.error()?.message }}</span>\n *     } @else {\n *       <h1>{{ postQuery.data().title }}</h1>\n *     }\n *   `,\n * })\n * export class Post {\n *   readonly postId = signal<number | undefined>(undefined)\n *   readonly postQuery = injectQuery(() => postOptions(this.postId()))\n * }\n * ```\n */\nexport function queryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n  QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions(options: unknown) {\n  return options\n}\n"],"mappings":";AAiSA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}

package/{signal-proxy.d.ts → dist/signal-proxy.d.mts}

@@ -1,7 +1,6 @@
-import { Signal } from '@angular/core';
-export type MapToSignals<T> = {
-    [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>;
-};
+import { Signal } from "@angular/core";
+//#region src/signal-proxy.d.ts
+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.
@@ -9,3 +8,5 @@ export type MapToSignals<T> = {
  * @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>;
+//#endregion
+//# sourceMappingURL=signal-proxy.d.mts.map

package/dist/signal-proxy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-proxy.d.mts","names":[],"sources":["../src/signal-proxy.ts"],"mappings":";;YAGY,aAAa,QACtB,WAAW,IAAI,EAAE,WAAW,WAAW,EAAE,KAAK,OAAO,EAAE;;;;;;;wBAS1C,YAAY,eAAe,8BACzC,aAAa,OAAO,UAAO,aAAA"}

package/dist/signal-proxy.mjs

@@ -0,0 +1,35 @@
+import { computed, untracked } from "@angular/core";
+//#region src/signal-proxy.ts
+/**
+* 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) {
+	return new Proxy({}, {
+		get(target, prop) {
+			const computedField = target[prop];
+			if (computedField) return computedField;
+			const targetField = untracked(inputSignal)[prop];
+			if (typeof targetField === "function") return targetField;
+			return target[prop] = computed(() => inputSignal()[prop]);
+		},
+		has(_, prop) {
+			return !!untracked(inputSignal)[prop];
+		},
+		ownKeys() {
+			return Reflect.ownKeys(untracked(inputSignal));
+		},
+		getOwnPropertyDescriptor() {
+			return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	});
+}
+//#endregion
+export { signalProxy };
+
+//# sourceMappingURL=signal-proxy.mjs.map

package/dist/signal-proxy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-proxy.mjs","names":[],"sources":["../src/signal-proxy.ts"],"sourcesContent":["import { computed, untracked } from '@angular/core'\nimport type { Signal } from '@angular/core'\n\nexport type MapToSignals<T> = {\n  [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>\n}\n\n/**\n * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.\n * Functions on the object are passed through as-is.\n * @param inputSignal - `Signal` that must return an object.\n * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.\n */\nexport function signalProxy<TInput extends Record<string | symbol, any>>(\n  inputSignal: Signal<TInput>,\n) {\n  const internalState = {} as MapToSignals<TInput>\n\n  return new Proxy<MapToSignals<TInput>>(internalState, {\n    get(target, prop) {\n      // first check if we have it in our internal state and return it\n      const computedField = target[prop]\n      if (computedField) return computedField\n\n      // then, check if it's a function on the resultState and return it\n      const targetField = untracked(inputSignal)[prop]\n      if (typeof targetField === 'function') return targetField\n\n      // finally, create a computed field, store it and return it\n      // @ts-expect-error\n      return (target[prop] = computed(() => inputSignal()[prop]))\n    },\n    has(_, prop) {\n      return !!untracked(inputSignal)[prop]\n    },\n    ownKeys() {\n      return Reflect.ownKeys(untracked(inputSignal))\n    },\n    getOwnPropertyDescriptor() {\n      return {\n        enumerable: true,\n        configurable: true,\n      }\n    },\n  })\n}\n"],"mappings":";;;;;;;;AAaA,SAAgB,YACd,aACA;CAGA,OAAO,IAAI,MAA4B,CAAY,GAAG;EACpD,IAAI,QAAQ,MAAM;GAEhB,MAAM,gBAAgB,OAAO;GAC7B,IAAI,eAAe,OAAO;GAG1B,MAAM,cAAc,UAAU,WAAW,CAAC,CAAC;GAC3C,IAAI,OAAO,gBAAgB,YAAY,OAAO;GAI9C,OAAQ,OAAO,QAAQ,eAAe,YAAY,CAAC,CAAC,KAAK;EAC3D;EACA,IAAI,GAAG,MAAM;GACX,OAAO,CAAC,CAAC,UAAU,WAAW,CAAC,CAAC;EAClC;EACA,UAAU;GACR,OAAO,QAAQ,QAAQ,UAAU,WAAW,CAAC;EAC/C;EACA,2BAA2B;GACzB,OAAO;IACL,YAAY;IACZ,cAAc;GAChB;EACF;CACF,CAAC;AACH"}

package/{types.d.ts → dist/types.d.mts}

@@ -1,6 +1,7 @@
-import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryKey, QueryObserverOptions, QueryObserverResult } from '@tanstack/query-core';
-import { Signal } from '@angular/core';
-import { MapToSignals } from './signal-proxy.js';
+import { MapToSignals } from "./signal-proxy.mjs";
+import { Signal } from "@angular/core";
+import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryKey, QueryObserverOptions, QueryObserverResult } from "@tanstack/query-core";
+//#region src/types.d.ts
 /**
  * The options shared across `angular-query-experimental`'s query functions. Extends
  * {@link QueryObserverOptions} from `@tanstack/query-core` as-is — unlike `react-query`,
@@ -14,8 +15,7 @@ import { MapToSignals } from './signal-proxy.js';
  * `placeholderData`. Defaults to, and is usually the same as, `TQueryFnData`.
  * @template TQueryKey - The type of your `queryKey`.
  */
-export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-}
+export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
 /**
  * The options accepted by `injectQuery`. Same as {@link CreateBaseQueryOptions}, minus `suspense` — which
  * `angular-query-experimental` doesn't support, unlike `react-query`.
@@ -26,10 +26,9 @@ export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = Default
  * `select` is used.
  * @template TQueryKey - The type of your `queryKey`.
  */
-export interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
-}
+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;
+  status: TStatus;
 }>;
 /**
  * The `isSuccess`/`isError`/`isPending` methods on a query result. Unlike `react-query`'s derived booleans,
@@ -41,9 +40,9 @@ type CreateStatusBasedQueryResult<TStatus extends QueryObserverResult['status'],
  * @template TError - The type of errors your `queryFn` may throw.
  */
 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>>;
+  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>>;
 }
 /**
  * The options accepted by `injectInfiniteQuery`. Same as {@link CreateBaseQueryOptions}, minus `suspense` —
@@ -59,8 +58,7 @@ export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
-}
+export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {}
 /**
  * The result of `injectQuery` when `initialData` isn't set — `data` may be `undefined` while the query is
  * `pending`. Same shape as {@link QueryObserverResult} from `@tanstack/query-core`, but value fields (like
@@ -118,8 +116,7 @@ export type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultEr
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
-}
+export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
 /**
  * The type of `mutate`, as returned by `injectMutation`. Forwards the variables (and an optional per-call
  * `onSuccess`/`onError`/`onSettled`) to the underlying `mutate` call. Fire-and-forget — errors are surfaced
@@ -155,15 +152,15 @@ export type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TV
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
 export type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
-    mutate: CreateMutateFunction<TData, TError, TVariables, TOnMutateResult>;
+  mutate: CreateMutateFunction<TData, TError, TVariables, TOnMutateResult>;
 }> & {
-    /**
-     * Similar to `mutate`, but returns a promise which can be awaited.
-     */
-    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
+  /**
+   * Similar to `mutate`, but returns a promise which can be awaited.
+   */
+  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
 };
 type CreateStatusBasedMutationResult<TStatus extends CreateBaseMutationResult['status'], TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Extract<CreateBaseMutationResult<TData, TError, TVariables, TOnMutateResult>, {
-    status: TStatus;
+  status: TStatus;
 }>;
 type SignalFunction<T extends () => any> = T & Signal<ReturnType<T>>;
 /**
@@ -178,10 +175,10 @@ type SignalFunction<T extends () => any> = T & Signal<ReturnType<T>>;
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
 export interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
-    isSuccess: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'success', TData, TError, TVariables, TOnMutateResult>>>;
-    isError: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'error', TData, TError, TVariables, TOnMutateResult>>>;
-    isPending: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'pending', TData, TError, TVariables, TOnMutateResult>>>;
-    isIdle: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TOnMutateResult>>>;
+  isSuccess: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'success', TData, TError, TVariables, TOnMutateResult>>>;
+  isError: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'error', TData, TError, TVariables, TOnMutateResult>>>;
+  isPending: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'pending', TData, TError, TVariables, TOnMutateResult>>>;
+  isIdle: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'idle', TData, TError, TVariables, TOnMutateResult>>>;
 }
 /**
  * The result of `injectMutation`. Based on {@link CreateBaseMutationResult}, but value fields are exposed as
@@ -196,4 +193,5 @@ export interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, T
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
 export type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown, TState = CreateStatusBasedMutationResult<CreateBaseMutationResult['status'], TData, TError, TVariables, TOnMutateResult>> = BaseMutationNarrowing<TData, TError, TVariables, TOnMutateResult> & MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>;
-export {};
+//#endregion
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;;;iBAiCiB,uBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;;;;;;;iBAae,mBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,uBAAuB,cAAc,QAAQ,OAAO,cAAc;KAI/D,6BACH,gBAAgB,+BAChB,iBACA,SAAS,gBACP,QAAQ,oBAAoB,OAAO;EAAW,QAAQ;;;;;;;;;;;iBAWzC,mBAAmB,iBAAiB,SAAS;EAC5D,YACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,wCAAwC,OAAO;EAEjD,UACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,sCAAsC,OAAO;EAE/C,YACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,wCAAwC,OAAO;;;;;;;;;;;;;;;;iBAkBlC,2BACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;;;;;;;;YAgBQ,sBACV,iBACA,SAAS,cACT,SAAS,oBAAoB,OAAO,WAClC,mBAAmB,OAAO,UAC5B,aAAa,UAAU,cAAc;;;;;;;YAQ3B,kBACV,iBACA,SAAS,gBACP,sBAAsB,OAAO;;;;;;;;;YAUrB,yBACV,iBACA,SAAS,cACT,SAAS,2BAA2B,OAAO,WACzC,mBAAmB,OAAO,UAC5B,aAAa,UAAU,cAAc;;;;;;;;;;YAW3B,0BACV,iBACA,SAAS,gBACP,mBAAmB,OAAO,UAC5B,aAAa,4BAA4B,OAAO;;;;;;;;;YAUtC,iCACV,iBACA,SAAS,cACT,gCAAgC,mCAC9B,OACA,WAEA,aAAa;;;;;;;;;;;iBAYA,sBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;;;;;;;;;;;;YAezC,qBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;YAclC,0BACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;;YAalC,yBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,qBAAqB,OAAO,QAAQ,YAAY;;;;;EAK1D,aAAa,0BACX,OACA,QACA,YACA;;KAIC,gCACH,gBAAgB,oCAChB,iBACA,SAAS,cACT,sBACA,6BACE,QACF,yBAAyB,OAAO,QAAQ,YAAY;EAClD,QAAQ;;KAGP,eAAe,uBAAuB,IAAI,OAAO,WAAW;;;;;;;;;;;;iBAahD,sBACf,iBACA,SAAS,cACT,sBACA;EAEA,WAAW,gBAEP,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,2CAEE,OACA,QACA,YACA;EAIN,SAAS,gBAEL,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,yCAEE,OACA,QACA,YACA;EAIN,WAAW,gBAEP,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,2CAEE,OACA,QACA,YACA;EAIN,QAAQ,gBAEJ,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,wCAEE,OACA,QACA,YACA;;;;;;;;;;;;;;YAkBI,qBACV,iBACA,SAAS,cACT,sBACA,2BACA,SAAS,gCACP,oCACA,OACA,QACA,YACA,oBAEA,sBAAsB,OAAO,QAAQ,YAAY,mBACnD,aAAa,UAAU,cAAc"}

package/dist/types.mjs

@@ -0,0 +1,6 @@
+//#region src/types.ts
+/* istanbul ignore file */
+//#endregion
+export {};
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"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  Override,\n  QueryKey,\n  QueryObserverOptions,\n  QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\nimport type { MapToSignals } from './signal-proxy'\n\n/**\n * The options shared across `angular-query-experimental`'s query functions. Extends\n * {@link QueryObserverOptions} from `@tanstack/query-core` as-is — unlike `react-query`,\n * `angular-query-experimental` has no extra framework-specific option here.\n *\n * @template TQueryFnData - The type your `queryFn` resolves to.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs. Defaults to `TQueryFnData` when no\n * `select` is used.\n * @template TQueryData - The type of the data actually held in the query cache — the input to `select` and\n * `placeholderData`. Defaults to, and is usually the same as, `TQueryFnData`.\n * @template TQueryKey - The type of your `queryKey`.\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 * The options accepted by `injectQuery`. Same as {@link CreateBaseQueryOptions}, minus `suspense` — which\n * `angular-query-experimental` doesn't support, unlike `react-query`.\n *\n * @template TQueryFnData - The type your `queryFn` resolves to.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs. Defaults to `TQueryFnData` when no\n * `select` is used.\n * @template TQueryKey - The type of your `queryKey`.\n */\nexport interface CreateQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n  CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\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\n/**\n * The `isSuccess`/`isError`/`isPending` methods on a query result. Unlike `react-query`'s derived booleans,\n * these are type-guard methods you call — `if (query.isSuccess())` — so that `query.data` narrows away\n * `undefined` inside the branch, the same way `status` narrowing works on the plain object `react-query`\n * returns.\n *\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TError - The type of errors your `queryFn` may throw.\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 * The options accepted by `injectInfiniteQuery`. Same as {@link CreateBaseQueryOptions}, minus `suspense` —\n * which `angular-query-experimental` doesn't support, unlike `react-query` — extends\n * {@link InfiniteQueryObserverOptions} from `@tanstack/query-core` for the infinite-query-specific options\n * (`getNextPageParam`, `initialPageParam`, etc.).\n *\n * @template TQueryFnData - The type of a single page, as your `queryFn` resolves it.\n * @template TError - The type of errors your `queryFn` may throw.\n * @template TData - The type `data` ends up as after `select` runs. Defaults to `TQueryFnData` here, though\n * `injectInfiniteQuery` itself defaults it to `InfiniteData<TQueryFnData>` — the shape `data` actually has\n * when no `select` is used.\n * @template TQueryKey - The type of your `queryKey`.\n * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.\n */\nexport interface CreateInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> extends OmitKeyof<\n  InfiniteQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  'suspense'\n> {}\n\n/**\n * The result of `injectQuery` when `initialData` isn't set — `data` may be `undefined` while the query is\n * `pending`. Same shape as {@link QueryObserverResult} from `@tanstack/query-core`, but value fields (like\n * `data`, `error`, `status`) are exposed as a `Signal` — read them with `query.data()`, not `query.data` —\n * while function fields (like `refetch`) are called directly, unchanged. `isSuccess`/`isError`/`isPending`\n * are {@link BaseQueryNarrowing} type-guard methods rather than plain booleans.\n * `injectInfiniteQuery` returns {@link CreateInfiniteQueryResult} instead.\n *\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TError - The type of errors your `queryFn` may throw.\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 * The result of `injectQuery`. Same as {@link CreateBaseQueryResult}.\n *\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TError - The type of errors your `queryFn` may throw.\n */\nexport type CreateQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n> = CreateBaseQueryResult<TData, TError>\n\n/**\n * The result of `injectQuery` when `initialData` is set — `data` is never `undefined`. Same shape as\n * {@link DefinedQueryObserverResult} from `@tanstack/query-core`, but value fields are exposed as a\n * `Signal` while function fields are called directly, unchanged.\n *\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TError - The type of errors your `queryFn` may throw.\n */\nexport type DefinedCreateQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TState = DefinedQueryObserverResult<TData, TError>,\n> = BaseQueryNarrowing<TData, TError> &\n  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>\n\n/**\n * The result of `injectInfiniteQuery` when `initialData` isn't set — `data` may be `undefined` while the\n * query is `pending`. Same shape as {@link InfiniteQueryObserverResult} from `@tanstack/query-core`, but\n * value fields are exposed as a `Signal` while function fields (like `fetchNextPage`) are called directly,\n * unchanged.\n *\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TError - The type of errors your `queryFn` may throw.\n */\nexport type CreateInfiniteQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n> = BaseQueryNarrowing<TData, TError> &\n  MapToSignals<InfiniteQueryObserverResult<TData, TError>>\n\n/**\n * The result of `injectInfiniteQuery` when `initialData` is set — `data` is never `undefined`. Same shape as\n * {@link DefinedInfiniteQueryObserverResult} from `@tanstack/query-core`, but value fields are exposed as a\n * `Signal` while function fields are called directly, unchanged.\n *\n * @template TData - The type `data` ends up as after `select` runs.\n * @template TError - The type of errors your `queryFn` may throw.\n */\nexport type DefinedCreateInfiniteQueryResult<\n  TData = unknown,\n  TError = DefaultError,\n  TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<\n    TData,\n    TError\n  >,\n> = MapToSignals<TDefinedInfiniteQueryObserver>\n\n/**\n * The options accepted by `injectMutation`. Same as {@link MutationObserverOptions} from\n * `@tanstack/query-core`, minus the internal `_defaulted` flag.\n *\n * @template TData - The type your mutation function resolves to.\n * @template TError - The type of errors your mutation function may throw.\n * @template TVariables - The type of the variable passed to `mutate`/`mutateAsync`.\n * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as\n * their `onMutateResult` parameter — useful for optimistic-update rollback data.\n */\nexport interface CreateMutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends OmitKeyof<\n  MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n  '_defaulted'\n> {}\n\n/**\n * The type of `mutate`, as returned by `injectMutation`. Forwards the variables (and an optional per-call\n * `onSuccess`/`onError`/`onSettled`) to the underlying `mutate` call. Fire-and-forget — errors are surfaced\n * through the mutation result, not thrown.\n *\n * @template TData - The type your mutation function resolves to.\n * @template TError - The type of errors your mutation function may throw.\n * @template TVariables - The type of the variable passed to `mutate`.\n * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as\n * their `onMutateResult` parameter — useful for optimistic-update rollback data.\n */\nexport type CreateMutateFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> = (\n  ...args: Parameters<\n    MutateFunction<TData, TError, TVariables, TOnMutateResult>\n  >\n) => void\n\n/**\n * The type of `mutateAsync`, as returned by `injectMutation`. Similar to {@link CreateMutateFunction}, but\n * returns a promise which can be awaited.\n *\n * @template TData - The type your mutation function resolves to.\n * @template TError - The type of errors your mutation function may throw.\n * @template TVariables - The type of the variable passed to `mutateAsync`.\n * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as\n * their `onMutateResult` parameter — useful for optimistic-update rollback data.\n */\nexport type CreateMutateAsyncFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\n/**\n * The pre-`Signal` shape {@link CreateMutationResult} is built from — not what `injectMutation` actually\n * returns. Same as {@link MutationObserverResult} from `@tanstack/query-core`, with `mutate` narrowed to the\n * fire-and-forget {@link CreateMutateFunction} signature, plus the added `mutateAsync`.\n *\n * @template TData - The type your mutation function resolves to.\n * @template TError - The type of errors your mutation function may throw.\n * @template TVariables - The type of the variable passed to `mutate`/`mutateAsync`.\n * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as\n * their `onMutateResult` parameter — useful for optimistic-update rollback data.\n */\nexport type CreateBaseMutationResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> = Override<\n  MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n  { mutate: CreateMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n  /**\n   * Similar to `mutate`, but returns a promise which can be awaited.\n   */\n  mutateAsync: CreateMutateAsyncFunction<\n    TData,\n    TError,\n    TVariables,\n    TOnMutateResult\n  >\n}\n\ntype CreateStatusBasedMutationResult<\n  TStatus extends CreateBaseMutationResult['status'],\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> = Extract<\n  CreateBaseMutationResult<TData, TError, TVariables, TOnMutateResult>,\n  { status: TStatus }\n>\n\ntype SignalFunction<T extends () => any> = T & Signal<ReturnType<T>>\n\n/**\n * The `isSuccess`/`isError`/`isPending`/`isIdle` methods on a mutation result. Each is both a `Signal`\n * (its current boolean value is read reactively without calling it) and a type-guard function you can\n * call — `if (mutation.isSuccess())` — so that `mutation.data` narrows away `undefined` inside the branch.\n *\n * @template TData - The type your mutation function resolves to.\n * @template TError - The type of errors your mutation function may throw.\n * @template TVariables - The type of the variable passed to `mutate`/`mutateAsync`.\n * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as\n * their `onMutateResult` parameter — useful for optimistic-update rollback data.\n */\nexport interface BaseMutationNarrowing<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n> {\n  isSuccess: SignalFunction<\n    (\n      this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>,\n    ) => this is CreateMutationResult<\n      TData,\n      TError,\n      TVariables,\n      TOnMutateResult,\n      CreateStatusBasedMutationResult<\n        'success',\n        TData,\n        TError,\n        TVariables,\n        TOnMutateResult\n      >\n    >\n  >\n  isError: SignalFunction<\n    (\n      this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>,\n    ) => this is CreateMutationResult<\n      TData,\n      TError,\n      TVariables,\n      TOnMutateResult,\n      CreateStatusBasedMutationResult<\n        'error',\n        TData,\n        TError,\n        TVariables,\n        TOnMutateResult\n      >\n    >\n  >\n  isPending: SignalFunction<\n    (\n      this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>,\n    ) => this is CreateMutationResult<\n      TData,\n      TError,\n      TVariables,\n      TOnMutateResult,\n      CreateStatusBasedMutationResult<\n        'pending',\n        TData,\n        TError,\n        TVariables,\n        TOnMutateResult\n      >\n    >\n  >\n  isIdle: SignalFunction<\n    (\n      this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>,\n    ) => this is CreateMutationResult<\n      TData,\n      TError,\n      TVariables,\n      TOnMutateResult,\n      CreateStatusBasedMutationResult<\n        'idle',\n        TData,\n        TError,\n        TVariables,\n        TOnMutateResult\n      >\n    >\n  >\n}\n\n/**\n * The result of `injectMutation`. Based on {@link CreateBaseMutationResult}, but value fields are exposed as\n * a `Signal` — read them with `mutation.data()`, not `mutation.data` — while function fields (`mutate`,\n * `mutateAsync`, `reset`) are called directly, unchanged. `isSuccess`/`isError`/`isPending`/`isIdle` are\n * {@link BaseMutationNarrowing} type-guard methods rather than plain booleans.\n *\n * @template TData - The type your mutation function resolves to.\n * @template TError - The type of errors your mutation function may throw.\n * @template TVariables - The type of the variable passed to `mutate`/`mutateAsync`.\n * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as\n * their `onMutateResult` parameter — useful for optimistic-update rollback data.\n */\nexport type CreateMutationResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = unknown,\n  TOnMutateResult = unknown,\n  TState = CreateStatusBasedMutationResult<\n    CreateBaseMutationResult['status'],\n    TData,\n    TError,\n    TVariables,\n    TOnMutateResult\n  >,\n> = BaseMutationNarrowing<TData, TError, TVariables, TOnMutateResult> &\n  MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>\n"],"mappings":""}