@tanstack/angular-query-experimental 5.103.1 → 5.103.3

package/dist/devtools-panel/inject-devtools-panel.mjs

@@ -0,0 +1,67 @@
+import { DestroyRef, Injector, PLATFORM_ID, assertInInjectionContext, computed, effect, inject, runInInjectionContext, untracked } from "@angular/core";
+import { QueryClient, onlineManager } from "@tanstack/query-core";
+import { isPlatformBrowser } from "@angular/common";
+//#region src/devtools-panel/inject-devtools-panel.ts
+/**
+* Inject a TanStack Query devtools panel and render it in the DOM.
+*
+* Devtools panel allows programmatic control over the devtools, for example if you want to render
+* the devtools as part of your own devtools.
+*
+* Consider `withDevtools` instead if you don't need this.
+* @param injectDevtoolsPanelFn - A function that returns devtools panel options.
+* @param options - Additional configuration
+* @returns DevtoolsPanelRef
+* @see https://tanstack.com/query/v5/docs/framework/angular/devtools
+*/
+const injectDevtoolsPanel = (injectDevtoolsPanelFn, options) => {
+	!options?.injector && assertInInjectionContext(injectDevtoolsPanel);
+	const currentInjector = options?.injector ?? inject(Injector);
+	return runInInjectionContext(currentInjector, () => {
+		const destroyRef = inject(DestroyRef);
+		const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+		const injectedClient = inject(QueryClient, { optional: true });
+		const queryOptions = computed(injectDevtoolsPanelFn);
+		let devtools = null;
+		const destroy = () => {
+			devtools?.unmount();
+			devtools = null;
+		};
+		if (!isBrowser) return { destroy };
+		effect(() => {
+			const { client = injectedClient, errorTypes = [], styleNonce, shadowDOMTarget, onClose, hostElement } = queryOptions();
+			untracked(() => {
+				if (!client) throw new Error("No QueryClient found");
+				if (!devtools && hostElement) import("@tanstack/query-devtools").then((queryDevtools) => {
+					devtools = new queryDevtools.TanstackQueryDevtoolsPanel({
+						client,
+						queryFlavor: "Angular Query",
+						version: "5",
+						buttonPosition: "bottom-left",
+						position: "bottom",
+						initialIsOpen: true,
+						errorTypes,
+						styleNonce,
+						shadowDOMTarget,
+						onClose,
+						onlineManager
+					});
+					devtools.mount(hostElement.nativeElement);
+				}).catch((error) => {
+					console.error("Install @tanstack/query-devtools or reinstall without --omit=optional.", error);
+				});
+				else if (devtools && hostElement) {
+					devtools.setClient(client);
+					devtools.setErrorTypes(errorTypes);
+					onClose && devtools.setOnClose(onClose);
+				} else if (devtools && !hostElement) destroy();
+			});
+		});
+		destroyRef.onDestroy(destroy);
+		return { destroy };
+	});
+};
+//#endregion
+export { injectDevtoolsPanel };
+
+//# sourceMappingURL=inject-devtools-panel.mjs.map

package/dist/devtools-panel/inject-devtools-panel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-devtools-panel.mjs","names":[],"sources":["../../src/devtools-panel/inject-devtools-panel.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  PLATFORM_ID,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  runInInjectionContext,\n  untracked,\n} from '@angular/core'\nimport { QueryClient, onlineManager } from '@tanstack/query-core'\nimport { isPlatformBrowser } from '@angular/common'\nimport type { TanstackQueryDevtoolsPanel } from '@tanstack/query-devtools'\nimport type {\n  DevtoolsPanelOptions,\n  InjectDevtoolsPanel,\n  InjectDevtoolsPanelOptions,\n} from './types'\n\n/**\n * Inject a TanStack Query devtools panel and render it in the DOM.\n *\n * Devtools panel allows programmatic control over the devtools, for example if you want to render\n * the devtools as part of your own devtools.\n *\n * Consider `withDevtools` instead if you don't need this.\n * @param injectDevtoolsPanelFn - A function that returns devtools panel options.\n * @param options - Additional configuration\n * @returns DevtoolsPanelRef\n * @see https://tanstack.com/query/v5/docs/framework/angular/devtools\n */\nexport const injectDevtoolsPanel: InjectDevtoolsPanel = (\n  injectDevtoolsPanelFn: () => DevtoolsPanelOptions,\n  options?: InjectDevtoolsPanelOptions,\n) => {\n  !options?.injector && assertInInjectionContext(injectDevtoolsPanel)\n  const currentInjector = options?.injector ?? inject(Injector)\n\n  return runInInjectionContext(currentInjector, () => {\n    const destroyRef = inject(DestroyRef)\n    const isBrowser = isPlatformBrowser(inject(PLATFORM_ID))\n    const injectedClient = inject(QueryClient, { optional: true })\n\n    const queryOptions = computed(injectDevtoolsPanelFn)\n    let devtools: TanstackQueryDevtoolsPanel | null = null\n\n    const destroy = () => {\n      devtools?.unmount()\n      devtools = null\n    }\n\n    if (!isBrowser)\n      return {\n        destroy,\n      }\n\n    effect(() => {\n      const {\n        client = injectedClient,\n        errorTypes = [],\n        styleNonce,\n        shadowDOMTarget,\n        onClose,\n        hostElement,\n      } = queryOptions()\n\n      untracked(() => {\n        if (!client) throw new Error('No QueryClient found')\n        if (!devtools && hostElement) {\n          import('@tanstack/query-devtools')\n            .then((queryDevtools) => {\n              devtools = new queryDevtools.TanstackQueryDevtoolsPanel({\n                client,\n                queryFlavor: 'Angular Query',\n                version: '5',\n                buttonPosition: 'bottom-left',\n                position: 'bottom',\n                initialIsOpen: true,\n                errorTypes,\n                styleNonce,\n                shadowDOMTarget,\n                onClose,\n                onlineManager,\n              })\n              devtools.mount(hostElement.nativeElement)\n            })\n            .catch((error) => {\n              console.error(\n                'Install @tanstack/query-devtools or reinstall without --omit=optional.',\n                error,\n              )\n            })\n        } else if (devtools && hostElement) {\n          devtools.setClient(client)\n          devtools.setErrorTypes(errorTypes)\n          onClose && devtools.setOnClose(onClose)\n        } else if (devtools && !hostElement) {\n          destroy()\n        }\n      })\n    })\n\n    destroyRef.onDestroy(destroy)\n\n    return {\n      destroy,\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgCA,MAAa,uBACX,uBACA,YACG;CACH,CAAC,SAAS,YAAY,yBAAyB,mBAAmB;CAClE,MAAM,kBAAkB,SAAS,YAAY,OAAO,QAAQ;CAE5D,OAAO,sBAAsB,uBAAuB;EAClD,MAAM,aAAa,OAAO,UAAU;EACpC,MAAM,YAAY,kBAAkB,OAAO,WAAW,CAAC;EACvD,MAAM,iBAAiB,OAAO,aAAa,EAAE,UAAU,KAAK,CAAC;EAE7D,MAAM,eAAe,SAAS,qBAAqB;EACnD,IAAI,WAA8C;EAElD,MAAM,gBAAgB;GACpB,UAAU,QAAQ;GAClB,WAAW;EACb;EAEA,IAAI,CAAC,WACH,OAAO,EACL,QACF;EAEF,aAAa;GACX,MAAM,EACJ,SAAS,gBACT,aAAa,CAAC,GACd,YACA,iBACA,SACA,gBACE,aAAa;GAEjB,gBAAgB;IACd,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,sBAAsB;IACnD,IAAI,CAAC,YAAY,aACf,OAAO,2BAA2B,CAC/B,MAAM,kBAAkB;KACvB,WAAW,IAAI,cAAc,2BAA2B;MACtD;MACA,aAAa;MACb,SAAS;MACT,gBAAgB;MAChB,UAAU;MACV,eAAe;MACf;MACA;MACA;MACA;MACA;KACF,CAAC;KACD,SAAS,MAAM,YAAY,aAAa;IAC1C,CAAC,CAAC,CACD,OAAO,UAAU;KAChB,QAAQ,MACN,0EACA,KACF;IACF,CAAC;SACE,IAAI,YAAY,aAAa;KAClC,SAAS,UAAU,MAAM;KACzB,SAAS,cAAc,UAAU;KACjC,WAAW,SAAS,WAAW,OAAO;IACxC,OAAO,IAAI,YAAY,CAAC,aACtB,QAAQ;GAEZ,CAAC;EACH,CAAC;EAED,WAAW,UAAU,OAAO;EAE5B,OAAO,EACL,QACF;CACF,CAAC;AACH"}

package/dist/devtools-panel/production/index.d.mts

@@ -0,0 +1,4 @@
+import { DevtoolsPanelOptions, DevtoolsPanelRef, InjectDevtoolsPanel, InjectDevtoolsPanelOptions } from "../types.mjs";
+import { injectDevtoolsPanel } from "../inject-devtools-panel.mjs";
+import "../index.mjs";
+export { type DevtoolsPanelOptions, type DevtoolsPanelRef, type InjectDevtoolsPanel, type InjectDevtoolsPanelOptions, injectDevtoolsPanel };

package/dist/devtools-panel/production/index.mjs

@@ -0,0 +1,2 @@
+import { injectDevtoolsPanel } from "../inject-devtools-panel.mjs";
+export { injectDevtoolsPanel };

package/dist/devtools-panel/stub.d.mts

@@ -0,0 +1,6 @@
+import { InjectDevtoolsPanel } from "./types.mjs";
+//#region src/devtools-panel/stub.d.ts
+declare const injectDevtoolsPanel: InjectDevtoolsPanel;
+//#endregion
+export { injectDevtoolsPanel };
+//# sourceMappingURL=stub.d.mts.map

package/dist/devtools-panel/stub.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.d.mts","names":[],"sources":["../../src/devtools-panel/stub.ts"],"mappings":";;cAIa,qBAAqB"}

package/dist/devtools-panel/stub.mjs

@@ -0,0 +1,7 @@
+import { noop } from "@tanstack/query-core";
+//#region src/devtools-panel/stub.ts
+const injectDevtoolsPanel = () => ({ destroy: noop });
+//#endregion
+export { injectDevtoolsPanel };
+
+//# sourceMappingURL=stub.mjs.map

package/dist/devtools-panel/stub.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.mjs","names":[],"sources":["../../src/devtools-panel/stub.ts"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport type { InjectDevtoolsPanel } from './types'\n\n// Stub which replaces `injectDevtoolsPanel` in production builds\nexport const injectDevtoolsPanel: InjectDevtoolsPanel = () => ({\n  destroy: noop,\n})\n"],"mappings":";;AAIA,MAAa,6BAAkD,EAC7D,SAAS,KACX"}

package/dist/devtools-panel/types.d.mts

@@ -0,0 +1,52 @@
+import { ElementRef, Injector } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+import { DevtoolsErrorType } from "@tanstack/query-devtools";
+//#region src/devtools-panel/types.d.ts
+interface InjectDevtoolsPanelOptions {
+  /**
+   * The `Injector` in which to create the devtools panel.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
+  injector?: Injector;
+}
+/**
+ * A devtools panel, which can be manually destroyed.
+ */
+interface DevtoolsPanelRef {
+  /**
+   * Destroy the panel, removing it from the DOM and stops listening to signal changes.
+   */
+  destroy: () => void;
+}
+interface DevtoolsPanelOptions {
+  /**
+   * Custom instance of QueryClient
+   */
+  client?: QueryClient;
+  /**
+   * Use this so you can define custom errors that can be shown in the devtools.
+   */
+  errorTypes?: Array<DevtoolsErrorType>;
+  /**
+   * Use this to pass a nonce to the style tag that is added to the document head. This is useful if you are using a Content Security Policy (CSP) nonce to allow inline styles.
+   */
+  styleNonce?: string;
+  /**
+   * Use this so you can attach the devtool's styles to specific element in the DOM.
+   */
+  shadowDOMTarget?: ShadowRoot;
+  /**
+   * Callback function that is called when the devtools panel is closed
+   */
+  onClose?: () => void;
+  /**
+   * Element where to render the devtools panel. When set to undefined or null, the devtools panel will not be created, or destroyed if existing.
+   * If changed from undefined to an ElementRef, the devtools panel will be created.
+   */
+  hostElement?: ElementRef;
+}
+type InjectDevtoolsPanel = (injectDevtoolsPanelFn: () => DevtoolsPanelOptions, options?: InjectDevtoolsPanelOptions) => DevtoolsPanelRef;
+//#endregion
+export { DevtoolsPanelOptions, DevtoolsPanelRef, InjectDevtoolsPanel, InjectDevtoolsPanelOptions };
+//# sourceMappingURL=types.d.mts.map

package/dist/devtools-panel/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/devtools-panel/types.ts"],"mappings":";;;;UAIiB;;;;;;EAMf,WAAW;;;;;UAMI;;;;EAIf;;UAGe;;;;EAIf,SAAS;;;;EAIT,aAAa,MAAM;;;;EAInB;;;;EAIA,kBAAkB;;;;EAKlB;;;;;EAMA,cAAc;;KAGJ,uBACV,6BAA6B,sBAC7B,UAAU,+BACP"}

package/dist/devtools-panel/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+import { BaseMutationNarrowing, BaseQueryNarrowing, CreateBaseMutationResult, CreateBaseQueryOptions, CreateBaseQueryResult, CreateInfiniteQueryOptions, CreateInfiniteQueryResult, CreateMutateAsyncFunction, CreateMutateFunction, CreateMutationOptions, CreateMutationResult, CreateQueryOptions, CreateQueryResult, DefinedCreateInfiniteQueryResult, DefinedCreateQueryResult } from "./types.mjs";
+import { DevtoolsFeature, PersistQueryClientFeature, QueryFeature, QueryFeatures, provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeature } from "./providers.mjs";
+import { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions } from "./query-options.mjs";
+import { mutationOptions } from "./mutation-options.mjs";
+import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions } from "./infinite-query-options.mjs";
+import { InjectInfiniteQueryOptions, injectInfiniteQuery } from "./inject-infinite-query.mjs";
+import { InjectIsFetchingOptions, injectIsFetching } from "./inject-is-fetching.mjs";
+import { InjectIsMutatingOptions, injectIsMutating } from "./inject-is-mutating.mjs";
+import { injectIsRestoring, provideIsRestoring } from "./inject-is-restoring.mjs";
+import { InjectMutationOptions, injectMutation } from "./inject-mutation.mjs";
+import { InjectMutationStateOptions, injectMutationState } from "./inject-mutation-state.mjs";
+import { QueriesOptions, QueriesResults } from "./inject-queries.mjs";
+import { InjectQueryOptions, injectQuery } from "./inject-query.mjs";
+import { injectQueryClient } from "./inject-query-client.mjs";
+export * from "@tanstack/query-core";
+export { BaseMutationNarrowing, BaseQueryNarrowing, CreateBaseMutationResult, CreateBaseQueryOptions, CreateBaseQueryResult, CreateInfiniteQueryOptions, CreateInfiniteQueryResult, CreateMutateAsyncFunction, CreateMutateFunction, CreateMutationOptions, CreateMutationResult, CreateQueryOptions, CreateQueryResult, DefinedCreateInfiniteQueryResult, DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DevtoolsFeature, type InjectInfiniteQueryOptions, type InjectIsFetchingOptions, type InjectIsMutatingOptions, type InjectMutationOptions, type InjectMutationStateOptions, type InjectQueryOptions, type PersistQueryClientFeature, type QueriesOptions, type QueriesResults, type QueryFeature, type QueryFeatures, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UnusedSkipTokenInfiniteOptions, type UnusedSkipTokenOptions, infiniteQueryOptions, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectIsRestoring, injectMutation, injectMutationState, injectQuery, injectQueryClient, mutationOptions, provideAngularQuery, provideIsRestoring, provideQueryClient, provideTanStackQuery, queryFeature, queryOptions };

package/{index.mjs → dist/index.mjs}

@@ -1,32 +1,19 @@
-export * from "@tanstack/query-core";
+import { injectIsRestoring, provideIsRestoring } from "./inject-is-restoring.mjs";
 import { queryOptions } from "./query-options.mjs";
 import { mutationOptions } from "./mutation-options.mjs";
 import { infiniteQueryOptions } from "./infinite-query-options.mjs";
 import { injectInfiniteQuery } from "./inject-infinite-query.mjs";
 import { injectIsFetching } from "./inject-is-fetching.mjs";
 import { injectIsMutating } from "./inject-is-mutating.mjs";
-import { injectIsRestoring, provideIsRestoring } from "./inject-is-restoring.mjs";
 import { injectMutation } from "./inject-mutation.mjs";
 import { injectMutationState } from "./inject-mutation-state.mjs";
 import { injectQuery } from "./inject-query.mjs";
 import { injectQueryClient } from "./inject-query-client.mjs";
 import { provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeature } from "./providers.mjs";
-export {
-  infiniteQueryOptions,
-  injectInfiniteQuery,
-  injectIsFetching,
-  injectIsMutating,
-  injectIsRestoring,
-  injectMutation,
-  injectMutationState,
-  injectQuery,
-  injectQueryClient,
-  mutationOptions,
-  provideAngularQuery,
-  provideIsRestoring,
-  provideQueryClient,
-  provideTanStackQuery,
-  queryFeature,
-  queryOptions
-};
-//# sourceMappingURL=index.mjs.map
+export * from "@tanstack/query-core";
+//#region src/index.ts
+/* istanbul ignore file */
+//#endregion
+export { infiniteQueryOptions, injectInfiniteQuery, injectIsFetching, injectIsMutating, injectIsRestoring, injectMutation, injectMutationState, injectQuery, injectQueryClient, mutationOptions, provideAngularQuery, provideIsRestoring, provideQueryClient, provideTanStackQuery, queryFeature, queryOptions };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/* istanbul ignore file */\n\n// Re-export core\nexport * from '@tanstack/query-core'\n\nexport * from './types'\n\nexport type {\n  DefinedInitialDataOptions,\n  UndefinedInitialDataOptions,\n  UnusedSkipTokenOptions,\n} from './query-options'\nexport { queryOptions } from './query-options'\n\nexport type { CreateMutationOptions } from './types'\nexport { mutationOptions } from './mutation-options'\n\nexport type {\n  DefinedInitialDataInfiniteOptions,\n  UndefinedInitialDataInfiniteOptions,\n  UnusedSkipTokenInfiniteOptions,\n} from './infinite-query-options'\nexport { infiniteQueryOptions } from './infinite-query-options'\n\nexport type { InjectInfiniteQueryOptions } from './inject-infinite-query'\nexport { injectInfiniteQuery } from './inject-infinite-query'\n\nexport type { InjectIsFetchingOptions } from './inject-is-fetching'\nexport { injectIsFetching } from './inject-is-fetching'\n\nexport type { InjectIsMutatingOptions } from './inject-is-mutating'\nexport { injectIsMutating } from './inject-is-mutating'\n\nexport { injectIsRestoring, provideIsRestoring } from './inject-is-restoring'\n\nexport type { InjectMutationOptions } from './inject-mutation'\nexport { injectMutation } from './inject-mutation'\n\nexport type { InjectMutationStateOptions } from './inject-mutation-state'\nexport { injectMutationState } from './inject-mutation-state'\n\nexport type { QueriesOptions, QueriesResults } from './inject-queries'\n\nexport type { InjectQueryOptions } from './inject-query'\nexport { injectQuery } from './inject-query'\n\nexport { injectQueryClient } from './inject-query-client'\n\nexport type {\n  DevtoolsFeature,\n  PersistQueryClientFeature,\n  QueryFeature,\n  QueryFeatures,\n} from './providers'\nexport {\n  provideAngularQuery,\n  provideQueryClient,\n  provideTanStackQuery,\n  queryFeature,\n} from './providers'\n"],"mappings":""}

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

@@ -1,5 +1,6 @@
-import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from '@tanstack/query-core';
-import { CreateInfiniteQueryOptions } from './types.js';
+import { CreateInfiniteQueryOptions } from "./types.mjs";
+import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
+//#region src/infinite-query-options.d.ts
 /**
  * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set — `data`
  * may be `undefined` while the query is `pending`.
@@ -11,15 +12,15 @@ import { CreateInfiniteQueryOptions } from './types.js';
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    /**
-     * 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 | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
+type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+  /**
+   * 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 | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
 };
 /**
  * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set and
@@ -33,14 +34,14 @@ export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultEr
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, '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<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken | undefined>;
+type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, '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<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken | undefined>;
 };
 /**
  * The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is
@@ -53,15 +54,15 @@ export type UnusedSkipTokenInfiniteOptions<TQueryFnData, 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 type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
-    /**
-     * 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<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) | undefined;
+type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+  /**
+   * 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<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) | undefined;
 };
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
@@ -109,7 +110,7 @@ export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultErro
  * }
  * ```
  */
-export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
  * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
@@ -161,7 +162,7 @@ export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError
  * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to
  * `injectInfiniteQuery`.
  */
-export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
  * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
@@ -213,4 +214,7 @@ export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError
  * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to
  * `injectInfiniteQuery`.
  */
-export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+//#endregion
+export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
+//# sourceMappingURL=infinite-query-options.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"infinite-query-options.d.mts","names":[],"sources":["../src/infinite-query-options.ts"],"mappings":";;;;;;;;;;;;;;KAuBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,2BACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;KAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,2BACE,cACA,QACA,OACA,WACA;;;;;;;EAUF,UAAU,QACR,2BACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;KAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,2BACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkD1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqD7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqD7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}

package/dist/infinite-query-options.mjs

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

package/dist/infinite-query-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"infinite-query-options.mjs","names":[],"sources":["../src/infinite-query-options.ts"],"sourcesContent":["import type {\n  DefaultError,\n  InfiniteData,\n  InitialDataFunction,\n  NonUndefinedGuard,\n  OmitKeyof,\n  QueryKey,\n  QueryKeyWithDataTag,\n  SkipToken,\n} from '@tanstack/query-core'\nimport type { CreateInfiniteQueryOptions } from './types'\n\n/**\n * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set — `data`\n * may be `undefined` while the query is `pending`.\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 `InfiniteData<TQueryFnData>`,\n * the shape of all fetched pages plus their page params.\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 type UndefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = CreateInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\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    | undefined\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | InitialDataFunction<\n        NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n      >\n}\n\n/**\n * The options accepted by the `infiniteQueryOptions` overload selected when no `initialData` is set and\n * `queryFn` is not `skipToken` — same as {@link UndefinedInitialDataInfiniteOptions}, but `queryFn` may not be\n * `skipToken`.\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 `InfiniteData<TQueryFnData>`,\n * the shape of all fetched pages plus their page params.\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 type UnusedSkipTokenInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = OmitKeyof<\n  CreateInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\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    CreateInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >['queryFn'],\n    SkipToken | undefined\n  >\n}\n\n/**\n * The options accepted by the `infiniteQueryOptions` overload selected when `initialData` is set — `data` is\n * never `undefined` (unless a `select` changes `TData` to include `undefined`).\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 `InfiniteData<TQueryFnData>`,\n * the shape of all fetched pages plus their page params.\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 type DefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = CreateInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\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<InfiniteData<TQueryFnData, TPageParam>>\n    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n    | undefined\n}\n\n/**\n * You can generally pass everything to `infiniteQueryOptions` that you can also pass to\n * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as\n * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options\n * for.\n *\n * This overload is selected when `initialData` is set.\n *\n * @see {@link injectInfiniteQuery} to run an infinite query with these options.\n * @param options - The {@link DefinedInitialDataInfiniteOptions} to use — everything you can pass to\n * `injectInfiniteQuery`, with `initialData` set.\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages, from a button click or\n * automatically as the user scrolls.\n *\n * @example\n * ```angular-ts\n * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'\n *\n * export const projectsOptions = infiniteQueryOptions({\n *   queryKey: ['projects'],\n *   queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *   initialPageParam: 0,\n *   getNextPageParam: (lastPage) => lastPage.nextId,\n *   initialData: { pages: [], pageParams: [] },\n * })\n *\n * @Component({\n *   selector: 'projects',\n *   template: `\n *     <!-- `projectsQuery.data()` is never `undefined`, thanks to `initialData` — even if a\n *     refetch fails, so the list stays visible alongside the error. -->\n *     <ul>\n *       @for (page of projectsQuery.data().pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Projects {\n *   readonly projectsQuery = injectInfiniteQuery(() => projectsOptions)\n * }\n * ```\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: DefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): DefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * You can generally pass everything to `infiniteQueryOptions` that you can also pass to\n * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as\n * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options\n * for.\n *\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages, from a button click or\n * automatically as the user scrolls.\n *\n * @example\n * A parameterized factory, so the same options object can be reused per `postId`:\n * ```angular-ts\n * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'\n *\n * export const commentsOptions = (postId: string) =>\n *   infiniteQueryOptions({\n *     queryKey: ['post', postId, 'comments'],\n *     queryFn: ({ pageParam }) => fetchComments(postId, pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   })\n *\n * @Component({\n *   selector: 'comments',\n *   template: `\n *     @if (commentsQuery.isPending()) {\n *       Loading...\n *     } @else if (commentsQuery.isError()) {\n *       <span>Error: {{ commentsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (page of commentsQuery.data().pages; track $index) {\n *           @for (comment of page.comments; track comment.id) {\n *             <li>{{ comment.text }}</li>\n *           }\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Comments {\n *   readonly postId = signal('1')\n *   readonly commentsQuery = injectInfiniteQuery(() => commentsOptions(this.postId()))\n * }\n * ```\n *\n * @see {@link injectInfiniteQuery} to run an infinite query with these options.\n * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to\n * `injectInfiniteQuery`.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UnusedSkipTokenInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): UnusedSkipTokenInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\n/**\n * You can generally pass everything to `infiniteQueryOptions` that you can also pass to\n * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as\n * `queryClient.fetchInfiniteQuery`. `options.queryKey` is required and is the query key to generate options\n * for.\n *\n * @returns The same options object, typed so that `queryKey` carries the inferred data type.\n * @remarks See {@link injectInfiniteQuery} for examples that fetch further pages (from a button click or\n * automatically as the user scrolls) and that use `skipToken` to disable the query until `postId` is set.\n *\n * @example\n * A parameterized factory, so the same options object can be reused per `postId`:\n * ```angular-ts\n * import { infiniteQueryOptions, injectInfiniteQuery } from '@tanstack/angular-query-experimental'\n *\n * export const commentsOptions = (postId: string) =>\n *   infiniteQueryOptions({\n *     queryKey: ['post', postId, 'comments'],\n *     queryFn: ({ pageParam }) => fetchComments(postId, pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   })\n *\n * @Component({\n *   selector: 'comments',\n *   template: `\n *     @if (commentsQuery.isPending()) {\n *       Loading...\n *     } @else if (commentsQuery.isError()) {\n *       <span>Error: {{ commentsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (page of commentsQuery.data().pages; track $index) {\n *           @for (comment of page.comments; track comment.id) {\n *             <li>{{ comment.text }}</li>\n *           }\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Comments {\n *   readonly postId = signal('1')\n *   readonly commentsQuery = injectInfiniteQuery(() => commentsOptions(this.postId()))\n * }\n * ```\n *\n * @see {@link injectInfiniteQuery} to run an infinite query with these options.\n * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to\n * `injectInfiniteQuery`.\n */\nexport function infiniteQueryOptions<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  options: UndefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n): UndefinedInitialDataInfiniteOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> &\n  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions(options: unknown) {\n  return options\n}\n"],"mappings":";AA+VA,SAAgB,qBAAqB,SAAkB;CACrD,OAAO;AACT"}

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

@@ -1,14 +1,15 @@
-import { Injector } from '@angular/core';
-import { DefaultError, InfiniteData, QueryKey } from '@tanstack/query-core';
-import { CreateInfiniteQueryOptions, CreateInfiniteQueryResult, DefinedCreateInfiniteQueryResult } from './types.js';
-import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from './infinite-query-options.js';
-export interface InjectInfiniteQueryOptions {
-    /**
-     * The `Injector` in which to create the infinite query.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
+import { CreateInfiniteQueryOptions, CreateInfiniteQueryResult, DefinedCreateInfiniteQueryResult } from "./types.mjs";
+import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from "./infinite-query-options.mjs";
+import { Injector } from "@angular/core";
+import { DefaultError, InfiniteData, QueryKey } from "@tanstack/query-core";
+//#region src/inject-infinite-query.d.ts
+interface InjectInfiniteQueryOptions {
+  /**
+   * The `Injector` in which to create the infinite query.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
+  injector?: Injector;
 }
 /**
  * The options for `injectInfiniteQuery` are identical to `injectQuery`, with the addition of
@@ -59,7 +60,7 @@ export interface InjectInfiniteQueryOptions {
  * }
  * ```
  */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): DefinedCreateInfiniteQueryResult<TData, TError>;
+declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): DefinedCreateInfiniteQueryResult<TData, TError>;
 /**
  * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a
  * unique key. Infinite queries can additively "load more" data onto an existing set of data, or
@@ -199,7 +200,7 @@ export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError,
  * }
  * ```
  */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
+declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
 /**
  * This overload accepts the general {@link CreateInfiniteQueryOptions} shape rather than the
  * `initialData`-aware overloads above, so whether `data` is defined can't be inferred from the call site —
@@ -211,4 +212,7 @@ export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError,
  * @param options - Additional configuration.
  * @returns The infinite query result.
  */
-export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
+declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
+//#endregion
+export { InjectInfiniteQueryOptions, injectInfiniteQuery };
+//# sourceMappingURL=inject-infinite-query.d.mts.map

package/dist/inject-infinite-query.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-infinite-query.d.mts","names":[],"sources":["../src/inject-infinite-query.ts"],"mappings":";;;;;UAwBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDG,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,kCAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,iCAAiC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6I3B,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,oCAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,0BAA0B,OAAO;;;;;;;;;;;;iBAapB,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,2BAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,0BAA0B,OAAO"}

package/dist/inject-infinite-query.mjs

@@ -0,0 +1,13 @@
+import { createBaseQuery } from "./create-base-query.mjs";
+import { Injector, assertInInjectionContext, inject, runInInjectionContext } from "@angular/core";
+import { InfiniteQueryObserver } from "@tanstack/query-core";
+//#region src/inject-infinite-query.ts
+function injectInfiniteQuery(injectInfiniteQueryFn, options) {
+	!options?.injector && assertInInjectionContext(injectInfiniteQuery);
+	const injector = options?.injector ?? inject(Injector);
+	return runInInjectionContext(injector, () => createBaseQuery(injectInfiniteQueryFn, InfiniteQueryObserver));
+}
+//#endregion
+export { injectInfiniteQuery };
+
+//# sourceMappingURL=inject-infinite-query.mjs.map

package/dist/inject-infinite-query.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-infinite-query.mjs","names":[],"sources":["../src/inject-infinite-query.ts"],"sourcesContent":["import { InfiniteQueryObserver } from '@tanstack/query-core'\nimport {\n  Injector,\n  assertInInjectionContext,\n  inject,\n  runInInjectionContext,\n} from '@angular/core'\nimport { createBaseQuery } from './create-base-query'\nimport type {\n  DefaultError,\n  InfiniteData,\n  QueryKey,\n  QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n  CreateInfiniteQueryOptions,\n  CreateInfiniteQueryResult,\n  DefinedCreateInfiniteQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataInfiniteOptions,\n  UndefinedInitialDataInfiniteOptions,\n} from './infinite-query-options'\n\nexport interface InjectInfiniteQueryOptions {\n  /**\n   * The `Injector` in which to create the infinite query.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector\n}\n\n/**\n * The options for `injectInfiniteQuery` are identical to `injectQuery`, with the addition of\n * `initialPageParam`, `getNextPageParam`, `getPreviousPageParam`, and `maxPages`. Infinite queries can\n * additively \"load more\" data onto an existing set of data, or \"infinite scroll\".\n *\n * This overload is selected when `initialData` is set on the options returned by `injectInfiniteQueryFn`,\n * so the resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).\n *\n * @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default\n * refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user\n * actions, or add conditions like `hasNextPage() && !isFetching()`.\n * @see {@link infiniteQueryOptions} to share these options between `injectInfiniteQuery` and imperative APIs\n * like `queryClient.fetchInfiniteQuery`.\n * @param injectInfiniteQueryFn - A function returning the {@link DefinedInitialDataInfiniteOptions} to use —\n * everything you can pass to `injectInfiniteQuery`, with `initialData` set. Similar to `computed` from\n * Angular, this function runs in the reactive context, so signals read inside it drive the query.\n * @param options - Additional configuration.\n * @returns The same signals as `injectQuery`, with the addition of `fetchNextPage`, `fetchPreviousPage`,\n * `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data().pages` and\n * `data().pageParams` are also added, as long as a `select` doesn't change `TData` away from its default\n * `InfiniteData<TQueryFnData>` shape.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'projects',\n *   template: `\n *     <!-- `projectsQuery.data()` is never `undefined`, thanks to `initialData` — even if a\n *     refetch fails, so the list stays visible alongside the error. -->\n *     <ul>\n *       @for (page of projectsQuery.data().pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Projects {\n *   readonly projectsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['projects'],\n *     queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *     initialData: { pages: [], pageParams: [] },\n *   }))\n * }\n * ```\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): DefinedCreateInfiniteQueryResult<TData, TError>\n\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a\n * unique key. Infinite queries can additively \"load more\" data onto an existing set of data, or\n * \"infinite scroll\".\n *\n * @remarks Keep in mind that imperative fetch calls, such as `fetchNextPage`, may interfere with the default\n * refetch behavior, resulting in outdated data. Make sure to call these functions only in response to user\n * actions, or add conditions like `hasNextPage() && !isFetching()`. This is the only overload that accepts\n * `queryFn: skipToken`, shown below.\n * @see {@link infiniteQueryOptions} to share these options between `injectInfiniteQuery` and imperative APIs\n * like `queryClient.fetchInfiniteQuery`.\n * @param injectInfiniteQueryFn - A function returning the {@link UndefinedInitialDataInfiniteOptions} to use\n * — everything you can pass to `injectInfiniteQuery`. Similar to `computed` from Angular, this function runs\n * in the reactive context, so signals read inside it drive the query.\n * @param options - Additional configuration.\n * @returns The same signals as `injectQuery`, with the addition of `fetchNextPage`, `fetchPreviousPage`,\n * `hasNextPage`, `hasPreviousPage`, `isFetchingNextPage`, and `isFetchingPreviousPage`. `data().pages` and\n * `data().pageParams` are also added, as long as a `select` doesn't change `TData` away from its default\n * `InfiniteData<TQueryFnData>` shape.\n *\n * @example\n * Fetching the next page from a button click:\n * ```angular-ts\n * @Component({\n *   selector: 'projects-list',\n *   template: `\n *     <ul>\n *       @for (page of projectsQuery.data()?.pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *     <button\n *       [disabled]=\"!projectsQuery.hasNextPage() || projectsQuery.isFetching()\"\n *       (click)=\"projectsQuery.fetchNextPage()\"\n *     >\n *       Load More\n *     </button>\n *   `,\n * })\n * export class ProjectsList {\n *   readonly projectsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['projects'],\n *     queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   }))\n * }\n * ```\n *\n * @example\n * Fetching the next page automatically as the user scrolls, using an `IntersectionObserver` on a sentinel\n * element after the list:\n * ```angular-ts\n * @Component({\n *   selector: 'projects-list',\n *   template: `\n *     <ul>\n *       @for (page of projectsQuery.data()?.pages; track $index) {\n *         @for (project of page.projects; track project.id) {\n *           <li>{{ project.name }}</li>\n *         }\n *       }\n *     </ul>\n *     <div #sentinel>{{ projectsQuery.isFetchingNextPage() ? 'Loading more...' : '' }}</div>\n *   `,\n * })\n * export class ProjectsList {\n *   readonly sentinel = viewChild<ElementRef<HTMLElement>>('sentinel')\n *\n *   readonly projectsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['projects'],\n *     queryFn: ({ pageParam }) => fetchProjects(pageParam),\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   }))\n *\n *   constructor() {\n *     effect((onCleanup) => {\n *       const sentinel = this.sentinel()?.nativeElement\n *       if (\n *         sentinel == null ||\n *         !this.projectsQuery.hasNextPage() ||\n *         this.projectsQuery.isFetching()\n *       ) {\n *         return\n *       }\n *\n *       const observer = new IntersectionObserver(([entry]) => {\n *         if (entry?.isIntersecting) this.projectsQuery.fetchNextPage()\n *       })\n *       observer.observe(sentinel)\n *\n *       onCleanup(() => observer.disconnect())\n *     })\n *   }\n * }\n * ```\n *\n * @example\n * A query that's disabled, type safe, until `postId` is set — pass `skipToken` as `queryFn` instead of\n * setting `enabled: false`:\n * ```angular-ts\n * @Component({\n *   selector: 'comments',\n *   template: `\n *     @if (postId() == null) {\n *       Select a post\n *     } @else if (commentsQuery.isPending()) {\n *       Loading...\n *     } @else if (commentsQuery.isError()) {\n *       <span>Error: {{ commentsQuery.error()?.message }}</span>\n *     } @else {\n *       <ul>\n *         @for (page of commentsQuery.data().pages; track $index) {\n *           @for (comment of page.comments; track comment.id) {\n *             <li>{{ comment.text }}</li>\n *           }\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Comments {\n *   readonly postId = signal<string | undefined>(undefined)\n *\n *   readonly commentsQuery = injectInfiniteQuery(() => ({\n *     queryKey: ['post', this.postId(), 'comments'],\n *     queryFn:\n *       this.postId() != null\n *         ? ({ pageParam }) => fetchComments(this.postId()!, pageParam)\n *         : skipToken,\n *     initialPageParam: 0,\n *     getNextPageParam: (lastPage) => lastPage.nextId,\n *   }))\n * }\n * ```\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): CreateInfiniteQueryResult<TData, TError>\n\n/**\n * This overload accepts the general {@link CreateInfiniteQueryOptions} shape rather than the\n * `initialData`-aware overloads above, so whether `data` is defined can't be inferred from the call site —\n * useful when wrapping `injectInfiniteQuery` in your own helper function that forwards caller-provided\n * options.\n *\n * @param injectInfiniteQueryFn - A function that returns infinite query options. Similar to `computed` from\n * Angular, this function runs in the reactive context, so signals read inside it drive the query.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n */\nexport function injectInfiniteQuery<\n  TQueryFnData,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  options?: InjectInfiniteQueryOptions,\n): CreateInfiniteQueryResult<TData, TError>\n\nexport function injectInfiniteQuery(\n  injectInfiniteQueryFn: () => CreateInfiniteQueryOptions,\n  options?: InjectInfiniteQueryOptions,\n) {\n  !options?.injector && assertInInjectionContext(injectInfiniteQuery)\n  const injector = options?.injector ?? inject(Injector)\n  return runInInjectionContext(injector, () =>\n    createBaseQuery(\n      injectInfiniteQueryFn,\n      InfiniteQueryObserver as typeof QueryObserver,\n    ),\n  )\n}\n"],"mappings":";;;;AA2RA,SAAgB,oBACd,uBACA,SACA;CACA,CAAC,SAAS,YAAY,yBAAyB,mBAAmB;CAClE,MAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;CACrD,OAAO,sBAAsB,gBAC3B,gBACE,uBACA,qBACF,CACF;AACF"}

package/{inject-is-fetching.d.ts → dist/inject-is-fetching.d.mts}

@@ -1,12 +1,13 @@
-import { Injector, Signal } from '@angular/core';
-import { QueryFilters } from '@tanstack/query-core';
-export interface InjectIsFetchingOptions {
-    /**
-     * The `Injector` in which to create the isFetching signal.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
+import { Injector, Signal } from "@angular/core";
+import { QueryFilters } from "@tanstack/query-core";
+//#region src/inject-is-fetching.d.ts
+interface InjectIsFetchingOptions {
+  /**
+   * The `Injector` in which to create the isFetching signal.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
+  injector?: Injector;
 }
 /**
  * Injects a signal that tracks the number of queries that your application is loading or fetching in the
@@ -49,4 +50,7 @@ export interface InjectIsFetchingOptions {
  * }
  * ```
  */
-export declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
+declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
+//#endregion
+export { InjectIsFetchingOptions, injectIsFetching };
+//# sourceMappingURL=inject-is-fetching.d.mts.map

package/dist/inject-is-fetching.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-fetching.d.mts","names":[],"sources":["../src/inject-is-fetching.ts"],"mappings":";;;UAYiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CG,iBACd,UAAU,cACV,UAAU,0BACT"}

package/dist/inject-is-fetching.mjs

@@ -0,0 +1,69 @@
+import { DestroyRef, Injector, NgZone, assertInInjectionContext, inject, signal } from "@angular/core";
+import { QueryClient, notifyManager } from "@tanstack/query-core";
+//#region src/inject-is-fetching.ts
+/**
+* Injects a signal that tracks the number of queries that your application is loading or fetching in the
+* background (useful for app-wide loading indicators).
+*
+* @param filters - The {@link QueryFilters} to narrow down the matched queries.
+* @param options - Additional configuration
+* @returns A `Signal` with the number of queries that your application is currently loading or fetching in
+* the background.
+*
+* @example
+* ```angular-ts
+* @Component({
+*   selector: 'posts-fetching-indicator',
+*   template: `
+*     @if (isFetchingPosts()) {
+*       <span>Refreshing posts...</span>
+*     }
+*   `,
+* })
+* export class PostsFetchingIndicator {
+*   // How many queries matching the posts prefix are fetching?
+*   readonly isFetchingPosts = injectIsFetching({ queryKey: ['posts'] })
+* }
+* ```
+*
+* @example
+* A global loading indicator for any query fetching in the background, not just the ones on screen:
+* ```angular-ts
+* @Component({
+*   selector: 'global-loading-indicator',
+*   template: `
+*     @if (isFetching()) {
+*       <div>Queries are fetching in the background...</div>
+*     }
+*   `,
+* })
+* export class GlobalLoadingIndicator {
+*   readonly isFetching = injectIsFetching()
+* }
+* ```
+*/
+function injectIsFetching(filters, options) {
+	!options?.injector && assertInInjectionContext(injectIsFetching);
+	const injector = options?.injector ?? inject(Injector);
+	const destroyRef = injector.get(DestroyRef);
+	const ngZone = injector.get(NgZone);
+	const queryClient = injector.get(QueryClient);
+	const cache = queryClient.getQueryCache();
+	let isFetching = queryClient.isFetching(filters);
+	const result = signal(isFetching);
+	const unsubscribe = ngZone.runOutsideAngular(() => cache.subscribe(notifyManager.batchCalls(() => {
+		const newIsFetching = queryClient.isFetching(filters);
+		if (isFetching !== newIsFetching) {
+			isFetching = newIsFetching;
+			ngZone.run(() => {
+				result.set(isFetching);
+			});
+		}
+	})));
+	destroyRef.onDestroy(unsubscribe);
+	return result;
+}
+//#endregion
+export { injectIsFetching };
+
+//# sourceMappingURL=inject-is-fetching.mjs.map