@tanstack/angular-query-experimental 5.103.1 → 5.103.3

package/dist/mutation-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-options.mjs","names":[],"sources":["../src/mutation-options.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { CreateMutationOptions } from './types'\n\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. A\n * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with\n * `injectMutationState`.\n *\n * @see {@link injectMutation} to run the mutation these options describe.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, with a\n * required `mutationKey`.\n * @returns The same options object, unchanged.\n *\n * @example\n * Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global \"saving…\" indicator:\n * ```angular-ts\n * import { mutationOptions, injectMutationState } from '@tanstack/angular-query-experimental'\n *\n * const createPostOptions = mutationOptions({\n *   mutationKey: ['posts', 'create'],\n *   mutationFn: createPost,\n * })\n *\n * @Component({\n *   selector: 'saving-indicator',\n *   template: `\n *     @if (isCreatingPost()) {\n *       <span>Saving…</span>\n *     }\n *   `,\n * })\n * export class SavingIndicator {\n *   readonly #pendingCreates = injectMutationState(() => ({\n *     filters: { mutationKey: createPostOptions.mutationKey, status: 'pending' },\n *   }))\n *   readonly isCreatingPost = computed(() => this.#pendingCreates().length > 0)\n * }\n * ```\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: WithRequired<\n    CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    'mutationKey'\n  >,\n): WithRequired<\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  'mutationKey'\n>\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. No\n * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a\n * `mutationKey` filter later (e.g. with `injectMutationState`); it can still be observed through other\n * filters, such as `status`.\n *\n * @see {@link injectMutation} to run the mutation these options describe.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, without a\n * `mutationKey`.\n * @returns The same options object, unchanged.\n * @remarks See the other overload's example for looking a mutation up via `injectMutationState`.\n *\n * @example\n * Sharing options across services, so `QueriesService` stays the single place a mutation is defined:\n * ```angular-ts\n * import { mutationOptions, injectMutation } from '@tanstack/angular-query-experimental'\n *\n * @Injectable({ providedIn: 'root' })\n * export class QueriesService {\n *   readonly #queryClient = inject(QueryClient)\n *\n *   updatePost(id: number) {\n *     return mutationOptions({\n *       mutationFn: (post: Partial<Post>) => putPost(id, post),\n *       onSuccess: (newPost) => this.#queryClient.setQueryData(['posts', id], newPost),\n *     })\n *   }\n * }\n *\n * @Component({\n *   selector: 'post',\n *   template: `<button (click)=\"save()\">Save</button>`,\n * })\n * export class Post {\n *   readonly queries = inject(QueriesService)\n *   readonly id = signal(0)\n *   readonly updatePostMutation = injectMutation(() => this.queries.updatePost(this.id()))\n *\n *   save() {\n *     this.updatePostMutation.mutate({ title: 'New Title' })\n *   }\n * }\n * ```\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: Omit<\n    CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n    'mutationKey'\n  >,\n): Omit<\n  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n  'mutationKey'\n>\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n>(\n  options: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): CreateMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n  return options\n}\n"],"mappings":";AA+GA,SAAgB,gBAMd,SACmE;CACnE,OAAO;AACT"}

package/dist/pending-tasks-compat.d.mts

@@ -0,0 +1,10 @@
+import { InjectionToken } from "@angular/core";
+//#region src/pending-tasks-compat.d.ts
+type PendingTasksCompat = {
+  add: () => PendingTaskRef;
+};
+type PendingTaskRef = () => void;
+declare const PENDING_TASKS: InjectionToken<PendingTasksCompat>;
+//#endregion
+export { PENDING_TASKS, PendingTaskRef };
+//# sourceMappingURL=pending-tasks-compat.d.mts.map

package/dist/pending-tasks-compat.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-tasks-compat.d.mts","names":[],"sources":["../src/pending-tasks-compat.ts"],"mappings":";;KAIK;EAAuB,WAAW;;KAE3B;cAEC,eAAa,eAAA"}

package/dist/pending-tasks-compat.mjs

@@ -0,0 +1,13 @@
+import * as ng from "@angular/core";
+import { InjectionToken, inject } from "@angular/core";
+import { noop } from "@tanstack/query-core";
+//#region src/pending-tasks-compat.ts
+const PENDING_TASKS = new InjectionToken("PENDING_TASKS", { factory: () => {
+	const token = Reflect.get(ng, "PendingTasks");
+	const svc = token ? inject(token, { optional: true }) : null;
+	return { add: svc ? () => svc.add() : () => noop };
+} });
+//#endregion
+export { PENDING_TASKS };
+
+//# sourceMappingURL=pending-tasks-compat.mjs.map

package/dist/pending-tasks-compat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-tasks-compat.mjs","names":[],"sources":["../src/pending-tasks-compat.ts"],"sourcesContent":["import { InjectionToken, inject } from '@angular/core'\nimport * as ng from '@angular/core'\nimport { noop } from '@tanstack/query-core'\n\ntype PendingTasksCompat = { add: () => PendingTaskRef }\n\nexport type PendingTaskRef = () => void\n\nexport const PENDING_TASKS = new InjectionToken<PendingTasksCompat>(\n  'PENDING_TASKS',\n  {\n    factory: (): PendingTasksCompat => {\n      // Access via Reflect so bundlers stay quiet when the token is absent (Angular < 19).\n      const token = Reflect.get(ng, 'PendingTasks') as unknown as\n        Parameters<typeof inject>[0] | undefined\n\n      const svc: PendingTasksCompat | null = token\n        ? (inject(token, { optional: true }) as PendingTasksCompat | null)\n        : null\n\n      // Without PendingTasks we fall back to a stable no-op shim.\n      return {\n        add: svc ? () => svc.add() : () => noop,\n      }\n    },\n  },\n)\n"],"mappings":";;;;AAQA,MAAa,gBAAgB,IAAI,eAC/B,iBACA,EACE,eAAmC;CAEjC,MAAM,QAAQ,QAAQ,IAAI,IAAI,cAAc;CAG5C,MAAM,MAAiC,QAClC,OAAO,OAAO,EAAE,UAAU,KAAK,CAAC,IACjC;CAGJ,OAAO,EACL,KAAK,YAAY,IAAI,IAAI,UAAU,KACrC;AACF,EACF,CACF"}

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

@@ -1,5 +1,6 @@
-import { InjectionToken, Provider } from '@angular/core';
-import { QueryClient } from '@tanstack/query-core';
+import { InjectionToken, Provider } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/providers.d.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 —
@@ -17,7 +18,7 @@ import { QueryClient } from '@tanstack/query-core';
  * })
  * ```
  */
-export declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
+declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
 /**
  * Sets up providers necessary to enable TanStack Query functionality for Angular applications. Allows
  * configuring a `QueryClient` and optional features such as developer tools.
@@ -80,7 +81,7 @@ export declare function provideQueryClient(queryClient: QueryClient | InjectionT
  * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
  * ```
  */
-export declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
+declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
 /**
  * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
  *
@@ -90,15 +91,15 @@ export declare function provideTanStackQuery(queryClient: QueryClient | Injectio
  * @returns A set of providers to set up TanStack Query.
  * @deprecated Use `provideTanStackQuery` instead.
  */
-export declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
+declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
 declare const queryFeatures: readonly ["Devtools", "PersistQueryClient"];
 type QueryFeatureKind = (typeof queryFeatures)[number];
 /**
  * Helper type to represent a Query feature.
  */
-export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
-    ɵkind: TFeatureKind;
-    ɵproviders: Array<Provider>;
+interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
+  ɵkind: TFeatureKind;
+  ɵproviders: Array<Provider>;
 }
 /**
  * Helper function to create an object that represents a Query feature.
@@ -106,18 +107,18 @@ export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
  * @param providers - The Angular providers this feature contributes to `provideTanStackQuery`.
  * @returns A Query feature.
  */
-export declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;
+declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;
 /**
  * A type alias that represents a feature which enables developer tools.
  * The type is used to describe the return value of the `withDevtools` function.
  * @see {@link withDevtools}
  */
-export type DevtoolsFeature = QueryFeature<'Devtools'>;
+type DevtoolsFeature = QueryFeature<'Devtools'>;
 /**
  * A type alias that represents a feature which enables persistence.
  * The type is used to describe the return value of the `withPersistQueryClient` function.
  */
-export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
+type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
 /**
  * A type alias that represents all Query features available for use with `provideTanStackQuery`.
  * Features can be enabled by adding special functions to the `provideTanStackQuery` call.
@@ -125,5 +126,7 @@ export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
  * documentation on how to use those functions.
  * @see {@link provideTanStackQuery}
  */
-export type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature;
-export {};
+type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature;
+//#endregion
+export { DevtoolsFeature, PersistQueryClientFeature, QueryFeature, QueryFeatures, provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeature };
+//# sourceMappingURL=providers.d.mts.map

package/dist/providers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.mts","names":[],"sources":["../src/providers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAqBgB,mBACd,aAAa,cAAc,eAAe,eACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Ea,qBACd,aAAa,cAAc,eAAe,iBACvC,UAAU,MAAM,iBAClB,MAAM;;;;;;;;;;iBAgBO,oBAAoB,aAAa,cAAc,MAAM;cAI/D;KAED,2BAA2B;;;;UAKf,aAAa,qBAAqB;EACjD,OAAO;EACP,YAAY,MAAM;;;;;;;;iBASJ,aAAa,qBAAqB,kBAChD,MAAM,cACN,WAAW,MAAM,YAChB,aAAa;;;;;;KASJ,kBAAkB;;;;;KAMlB,4BAA4B;;;;;;;;KAS5B,gBAAgB,kBAAkB"}

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`.
@@ -9,15 +10,15 @@ import { CreateQueryOptions } from './types.js';
  * @template TData - The type `data` ends up as after `select` runs.
  * @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>;
+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>;
 };
 /**
  * The options accepted by the `queryOptions` overload selected when no `initialData` is set and `queryFn` is
@@ -28,14 +29,14 @@ export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = Default
  * @template TData - The type `data` ends up as after `select` runs.
  * @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>;
+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>;
 };
 /**
  * The options accepted by the `queryOptions` overload selected when `initialData` is set — `data` is never
@@ -46,21 +47,21 @@ export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError
  * @template TData - The type `data` ends up as after `select` runs.
  * @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>;
+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>;
 };
 /**
  * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options
@@ -106,7 +107,7 @@ export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultEr
  * }
  * ```
  */
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
 /**
  * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options
  * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is
@@ -146,7 +147,7 @@ export declare function queryOptions<TQueryFnData = unknown, TError = DefaultErr
  * }
  * ```
  */
-export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
 /**
  * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options
  * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is
@@ -218,4 +219,7 @@ 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>;
+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
+export { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions };
+//# 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":";;;;;;;;;;;;KAqBY,4BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAQlD,0BAEI,oBAAoB,kBAAkB,iBACtC,kBAAkB;;;;;;;;;;;KAYZ,uBACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;EAShD,UAAU,QACR,mBAAmB,cAAc,QAAQ,OAAO,uBAChD;;;;;;;;;;;KAaQ,0BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,KACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAUhD,aACE,kBAAkB,uBAAuB,kBAAkB;;;;;;EAM7D,UAAU,cAAc,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,uBAAuB,cAAc,QAAQ,OAAO,aAC5D,uBAAuB,cAAc,QAAQ,OAAO,aACrD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyE/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/dist/signal-proxy.d.mts

@@ -0,0 +1,13 @@
+import { Signal } from "@angular/core";
+//#region src/signal-proxy.d.ts
+type MapToSignals<T> = { [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>; };
+/**
+ * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
+ * Functions on the object are passed through as-is.
+ * @param inputSignal - `Signal` that must return an object.
+ * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
+ */
+declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;
+//#endregion
+export { MapToSignals, signalProxy };
+//# 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":";;KAGY,aAAa,QACtB,WAAW,IAAI,EAAE,WAAW,WAAW,EAAE,KAAK,OAAO,EAAE;;;;;;;iBAS1C,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"}