@tanstack/angular-query-experimental 5.80.6 → 5.80.8

package/dist/providers.mjs

@@ -0,0 +1,109 @@
+import { InjectionToken, inject, DestroyRef, isDevMode, ENVIRONMENT_INITIALIZER, PLATFORM_ID, computed, effect } from "@angular/core";
+import { QueryClient, noop, onlineManager } from "@tanstack/query-core";
+import { isPlatformBrowser } from "@angular/common";
+function provideQueryClient(queryClient) {
+  return {
+    provide: QueryClient,
+    useFactory: () => {
+      const client = queryClient instanceof InjectionToken ? inject(queryClient) : queryClient;
+      inject(DestroyRef).onDestroy(() => client.unmount());
+      client.mount();
+      return client;
+    }
+  };
+}
+function provideTanStackQuery(queryClient, ...features) {
+  return [
+    provideQueryClient(queryClient),
+    features.map((feature) => feature.ɵproviders)
+  ];
+}
+function queryFeature(kind, providers) {
+  return { ɵkind: kind, ɵproviders: providers };
+}
+function withDevtools(withDevtoolsFn) {
+  let providers = [];
+  if (!isDevMode() && !withDevtoolsFn) {
+    providers = [];
+  } else {
+    providers = [
+      {
+        // Do not use provideEnvironmentInitializer while Angular < v19 is supported
+        provide: ENVIRONMENT_INITIALIZER,
+        multi: true,
+        useFactory: () => {
+          if (!isPlatformBrowser(inject(PLATFORM_ID))) return noop;
+          const injectedClient = inject(QueryClient, {
+            optional: true
+          });
+          const destroyRef = inject(DestroyRef);
+          const options = computed(() => (withDevtoolsFn == null ? void 0 : withDevtoolsFn()) ?? {});
+          let devtools = null;
+          let el = null;
+          const shouldLoadToolsSignal = computed(() => {
+            const { loadDevtools } = options();
+            return typeof loadDevtools === "boolean" ? loadDevtools : isDevMode();
+          });
+          const getResolvedQueryClient = () => {
+            const client = options().client ?? injectedClient;
+            if (!client) {
+              throw new Error("No QueryClient found");
+            }
+            return client;
+          };
+          const destroyDevtools = () => {
+            devtools == null ? void 0 : devtools.unmount();
+            el == null ? void 0 : el.remove();
+            devtools = null;
+          };
+          return () => effect(() => {
+            const shouldLoadTools = shouldLoadToolsSignal();
+            const {
+              client,
+              position,
+              errorTypes,
+              buttonPosition,
+              initialIsOpen
+            } = options();
+            if (devtools && !shouldLoadTools) {
+              destroyDevtools();
+              return;
+            } else if (devtools && shouldLoadTools) {
+              client && devtools.setClient(client);
+              position && devtools.setPosition(position);
+              errorTypes && devtools.setErrorTypes(errorTypes);
+              buttonPosition && devtools.setButtonPosition(buttonPosition);
+              initialIsOpen && devtools.setInitialIsOpen(initialIsOpen);
+              return;
+            } else if (!shouldLoadTools) {
+              return;
+            }
+            el = document.body.appendChild(document.createElement("div"));
+            el.classList.add("tsqd-parent-container");
+            import("@tanstack/query-devtools").then((queryDevtools) => {
+              devtools = new queryDevtools.TanstackQueryDevtools({
+                ...options(),
+                client: getResolvedQueryClient(),
+                queryFlavor: "Angular Query",
+                version: "5",
+                onlineManager
+              });
+              el && devtools.mount(el);
+              destroyRef.onDestroy(destroyDevtools);
+            });
+          });
+        }
+      }
+    ];
+  }
+  return queryFeature("DeveloperTools", providers);
+}
+const queryFeatures = ["DeveloperTools", "PersistQueryClient"];
+export {
+  provideQueryClient,
+  provideTanStackQuery,
+  queryFeature,
+  queryFeatures,
+  withDevtools
+};
+//# sourceMappingURL=providers.mjs.map

package/dist/providers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.mjs","sources":["../src/providers.ts"],"sourcesContent":["import {\n  DestroyRef,\n  ENVIRONMENT_INITIALIZER,\n  InjectionToken,\n  PLATFORM_ID,\n  computed,\n  effect,\n  inject,\n} from '@angular/core'\nimport { QueryClient, noop, onlineManager } from '@tanstack/query-core'\nimport { isPlatformBrowser } from '@angular/common'\nimport { isDevMode } from './util/is-dev-mode/is-dev-mode'\nimport type { Provider } from '@angular/core'\nimport type {\n  DevtoolsButtonPosition,\n  DevtoolsErrorType,\n  DevtoolsPosition,\n  TanstackQueryDevtools,\n} from '@tanstack/query-devtools'\n\n/**\n * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the\n * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}\n * for the entire application. Internally it calls `provideQueryClient`.\n * You can use `provideQueryClient` to provide a different `QueryClient` instance for a part\n * of the application or for unit testing purposes.\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 */\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.\n *\n * Allows to configure a `QueryClient` and optional features such as developer tools.\n *\n * **Example - standalone**\n *\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   QueryClient,\n * } from '@tanstack/angular-query-experimental'\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [provideTanStackQuery(new QueryClient())],\n * })\n * ```\n *\n * **Example - NgModule-based**\n *\n * ```ts\n * import {\n *   provideTanStackQuery,\n *   QueryClient,\n * } 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 * You can also enable optional developer tools by adding `withDevtools`. By\n * default the tools will then be loaded when 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 *   {\n *     providers: [\n *       provideTanStackQuery(new QueryClient(), withDevtools())\n *     ]\n *   }\n * )\n * ```\n *\n * **Example: using an InjectionToken**\n *\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 * @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 * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @see withDevtools\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 to configure a `QueryClient`.\n * @param queryClient - A `QueryClient` instance.\n * @returns A set of providers to set up TanStack Query.\n * @public\n * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start\n * @deprecated Use `provideTanStackQuery` instead.\n */\nexport function provideAngularQuery(queryClient: QueryClient): Array<Provider> {\n  return provideTanStackQuery(queryClient)\n}\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 -\n * @param providers -\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 * @public\n * @see {@link withDevtools}\n */\nexport type DeveloperToolsFeature = QueryFeature<'DeveloperTools'>\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 * @public\n */\nexport type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>\n\n/**\n * Options for configuring the TanStack Query devtools.\n * @public\n */\nexport interface DevtoolsOptions {\n  /**\n   * Set this true if you want the devtools to default to being open\n   */\n  initialIsOpen?: boolean\n  /**\n   * The position of the TanStack logo to open and close the devtools panel.\n   * `top-left` | `top-right` | `bottom-left` | `bottom-right` | `relative`\n   * Defaults to `bottom-right`.\n   */\n  buttonPosition?: DevtoolsButtonPosition\n  /**\n   * The position of the TanStack Query devtools panel.\n   * `top` | `bottom` | `left` | `right`\n   * Defaults to `bottom`.\n   */\n  position?: DevtoolsPosition\n  /**\n   * Custom instance of QueryClient\n   */\n  client?: QueryClient\n  /**\n   * Use this so you can define custom errors that can be shown in the devtools.\n   */\n  errorTypes?: Array<DevtoolsErrorType>\n  /**\n   * 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.\n   */\n  styleNonce?: string\n  /**\n   * Use this so you can attach the devtool's styles to a specific element in the DOM.\n   */\n  shadowDOMTarget?: ShadowRoot\n\n  /**\n   * Whether the developer tools should load.\n   * - `auto`- (Default) Lazily loads devtools when in development mode. Skips loading in production mode.\n   * - `true`- Always load the devtools, regardless of the environment.\n   * - `false`- Never load the devtools, regardless of the environment.\n   *\n   * You can use `true` and `false` to override loading developer tools from an environment file.\n   * For example, a test environment might run in production mode but you may want to load developer tools.\n   *\n   * Additionally, you can use a signal in the callback to dynamically load the devtools based on a condition. For example,\n   * a signal created from a RxJS observable that listens for a keyboard shortcut.\n   *\n   * **Example**\n   * ```ts\n   *    withDevtools(() => ({\n   *      initialIsOpen: true,\n   *      loadDevtools: inject(ExampleService).loadDevtools()\n   *    }))\n   *  ```\n   */\n  loadDevtools?: 'auto' | boolean\n}\n\n/**\n * Enables developer tools.\n *\n * **Example**\n *\n * ```ts\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideTanStackQuery(new QueryClient(), withDevtools())\n *   ]\n * }\n * ```\n * By default the devtools will be loaded when Angular runs in development mode and rendered in `<body>`.\n *\n * If you need more control over when devtools are loaded, you can use the `loadDevtools` option. This is particularly useful if you want to load devtools based on environment configurations. For instance, you might have a test environment running in production mode but still require devtools to be available.\n *\n * If you need more control over where devtools are rendered, consider `injectDevtoolsPanel`. This allows rendering devtools inside your own devtools for example.\n * @param withDevtoolsFn - A function that returns `DevtoolsOptions`.\n * @returns A set of providers for use with `provideTanStackQuery`.\n * @public\n * @see {@link provideTanStackQuery}\n * @see {@link DevtoolsOptions}\n */\nexport function withDevtools(\n  withDevtoolsFn?: () => DevtoolsOptions,\n): DeveloperToolsFeature {\n  let providers: Array<Provider> = []\n  if (!isDevMode() && !withDevtoolsFn) {\n    providers = []\n  } else {\n    providers = [\n      {\n        // Do not use provideEnvironmentInitializer while Angular < v19 is supported\n        provide: ENVIRONMENT_INITIALIZER,\n        multi: true,\n        useFactory: () => {\n          if (!isPlatformBrowser(inject(PLATFORM_ID))) return noop\n          const injectedClient = inject(QueryClient, {\n            optional: true,\n          })\n          const destroyRef = inject(DestroyRef)\n\n          const options = computed(() => withDevtoolsFn?.() ?? {})\n\n          let devtools: TanstackQueryDevtools | null = null\n          let el: HTMLElement | null = null\n\n          const shouldLoadToolsSignal = computed(() => {\n            const { loadDevtools } = options()\n            return typeof loadDevtools === 'boolean'\n              ? loadDevtools\n              : isDevMode()\n          })\n\n          const getResolvedQueryClient = () => {\n            const client = options().client ?? injectedClient\n            if (!client) {\n              throw new Error('No QueryClient found')\n            }\n            return client\n          }\n\n          const destroyDevtools = () => {\n            devtools?.unmount()\n            el?.remove()\n            devtools = null\n          }\n\n          return () =>\n            effect(() => {\n              const shouldLoadTools = shouldLoadToolsSignal()\n              const {\n                client,\n                position,\n                errorTypes,\n                buttonPosition,\n                initialIsOpen,\n              } = options()\n\n              if (devtools && !shouldLoadTools) {\n                destroyDevtools()\n                return\n              } else if (devtools && shouldLoadTools) {\n                client && devtools.setClient(client)\n                position && devtools.setPosition(position)\n                errorTypes && devtools.setErrorTypes(errorTypes)\n                buttonPosition && devtools.setButtonPosition(buttonPosition)\n                initialIsOpen && devtools.setInitialIsOpen(initialIsOpen)\n                return\n              } else if (!shouldLoadTools) {\n                return\n              }\n\n              el = document.body.appendChild(document.createElement('div'))\n              el.classList.add('tsqd-parent-container')\n\n              import('@tanstack/query-devtools').then((queryDevtools) => {\n                devtools = new queryDevtools.TanstackQueryDevtools({\n                  ...options(),\n                  client: getResolvedQueryClient(),\n                  queryFlavor: 'Angular Query',\n                  version: '5',\n                  onlineManager,\n                })\n\n                el && devtools.mount(el)\n\n                // Unmount the devtools on application destroy\n                destroyRef.onDestroy(destroyDevtools)\n              })\n            })\n        },\n      },\n    ]\n  }\n  return queryFeature('DeveloperTools', providers)\n}\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 * @public\n * @see {@link provideTanStackQuery}\n */\nexport type QueryFeatures = DeveloperToolsFeature | PersistQueryClientFeature\n\nexport const queryFeatures = ['DeveloperTools', 'PersistQueryClient'] as const\n\nexport type QueryFeatureKind = (typeof queryFeatures)[number]\n"],"names":[],"mappings":";;;AA6BO,SAAS,mBACd,aACU;AACH,SAAA;AAAA,IACL,SAAS;AAAA,IACT,YAAY,MAAM;AAChB,YAAM,SACJ,uBAAuB,iBACnB,OAAO,WAAW,IAClB;AAEN,aAAO,UAAU,EAAE,UAAU,MAAM,OAAO,SAAS;AACnD,aAAO,MAAM;AACN,aAAA;AAAA,IAAA;AAAA,EAEX;AACF;AAuEgB,SAAA,qBACd,gBACG,UACc;AACV,SAAA;AAAA,IACL,mBAAmB,WAAW;AAAA,IAC9B,SAAS,IAAI,CAAC,YAAY,QAAQ,UAAU;AAAA,EAC9C;AACF;AA8BgB,SAAA,aACd,MACA,WAC4B;AAC5B,SAAO,EAAE,OAAO,MAAM,YAAY,UAAU;AAC9C;AAqGO,SAAS,aACd,gBACuB;AACvB,MAAI,YAA6B,CAAC;AAClC,MAAI,CAAC,eAAe,CAAC,gBAAgB;AACnC,gBAAY,CAAC;AAAA,EAAA,OACR;AACO,gBAAA;AAAA,MACV;AAAA;AAAA,QAEE,SAAS;AAAA,QACT,OAAO;AAAA,QACP,YAAY,MAAM;AAChB,cAAI,CAAC,kBAAkB,OAAO,WAAW,CAAC,EAAU,QAAA;AAC9C,gBAAA,iBAAiB,OAAO,aAAa;AAAA,YACzC,UAAU;AAAA,UAAA,CACX;AACK,gBAAA,aAAa,OAAO,UAAU;AAEpC,gBAAM,UAAU,SAAS,OAAM,uDAAsB,CAAA,CAAE;AAEvD,cAAI,WAAyC;AAC7C,cAAI,KAAyB;AAEvB,gBAAA,wBAAwB,SAAS,MAAM;AACrC,kBAAA,EAAE,aAAa,IAAI,QAAQ;AACjC,mBAAO,OAAO,iBAAiB,YAC3B,eACA,UAAU;AAAA,UAAA,CACf;AAED,gBAAM,yBAAyB,MAAM;AAC7B,kBAAA,SAAS,UAAU,UAAU;AACnC,gBAAI,CAAC,QAAQ;AACL,oBAAA,IAAI,MAAM,sBAAsB;AAAA,YAAA;AAEjC,mBAAA;AAAA,UACT;AAEA,gBAAM,kBAAkB,MAAM;AAC5B,iDAAU;AACV,qCAAI;AACO,uBAAA;AAAA,UACb;AAEO,iBAAA,MACL,OAAO,MAAM;AACX,kBAAM,kBAAkB,sBAAsB;AACxC,kBAAA;AAAA,cACJ;AAAA,cACA;AAAA,cACA;AAAA,cACA;AAAA,cACA;AAAA,gBACE,QAAQ;AAER,gBAAA,YAAY,CAAC,iBAAiB;AAChB,8BAAA;AAChB;AAAA,YAAA,WACS,YAAY,iBAAiB;AAC5B,wBAAA,SAAS,UAAU,MAAM;AACvB,0BAAA,SAAS,YAAY,QAAQ;AAC3B,4BAAA,SAAS,cAAc,UAAU;AAC7B,gCAAA,SAAS,kBAAkB,cAAc;AAC1C,+BAAA,SAAS,iBAAiB,aAAa;AACxD;AAAA,YAAA,WACS,CAAC,iBAAiB;AAC3B;AAAA,YAAA;AAGF,iBAAK,SAAS,KAAK,YAAY,SAAS,cAAc,KAAK,CAAC;AACzD,eAAA,UAAU,IAAI,uBAAuB;AAExC,mBAAO,0BAA0B,EAAE,KAAK,CAAC,kBAAkB;AAC9C,yBAAA,IAAI,cAAc,sBAAsB;AAAA,gBACjD,GAAG,QAAQ;AAAA,gBACX,QAAQ,uBAAuB;AAAA,gBAC/B,aAAa;AAAA,gBACb,SAAS;AAAA,gBACT;AAAA,cAAA,CACD;AAEK,oBAAA,SAAS,MAAM,EAAE;AAGvB,yBAAW,UAAU,eAAe;AAAA,YAAA,CACrC;AAAA,UAAA,CACF;AAAA,QAAA;AAAA,MACL;AAAA,IAEJ;AAAA,EAAA;AAEK,SAAA,aAAa,kBAAkB,SAAS;AACjD;AAYa,MAAA,gBAAgB,CAAC,kBAAkB,oBAAoB;"}

package/dist/query-options.mjs

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

package/dist/query-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.mjs","sources":["../src/query-options.ts"],"sourcesContent":["import type {\n  DataTag,\n  DefaultError,\n  InitialDataFunction,\n  NonUndefinedGuard,\n  OmitKeyof,\n  QueryFunction,\n  QueryKey,\n  SkipToken,\n} from '@tanstack/query-core'\nimport type { CreateQueryOptions } from './types'\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  initialData?:\n    | undefined\n    | InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n    | NonUndefinedGuard<TQueryFnData>\n}\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  queryFn?: Exclude<\n    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n    SkipToken | undefined\n  >\n}\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  initialData:\n    | NonUndefinedGuard<TQueryFnData>\n    | (() => NonUndefinedGuard<TQueryFnData>)\n  queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\n/**\n * Allows to share and re-use query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n *\n * **Example**\n *\n * ```ts\n *  const { queryKey } = queryOptions({\n *     queryKey: ['key'],\n *     queryFn: () => Promise.resolve(5),\n *     //  ^?  Promise<number>\n *   })\n *\n *   const queryClient = new QueryClient()\n *   const data = queryClient.getQueryData(queryKey)\n *   //    ^?  number | undefined\n * ```\n * @param options - The query options to tag with the type from `queryFn`.\n * @returns The tagged query options.\n * @public\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  queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\n/**\n * Allows to share and re-use query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n *\n * **Example**\n *\n * ```ts\n *  const { queryKey } = queryOptions({\n *     queryKey: ['key'],\n *     queryFn: () => Promise.resolve(5),\n *     //  ^?  Promise<number>\n *   })\n *\n *   const queryClient = new QueryClient()\n *   const data = queryClient.getQueryData(queryKey)\n *   //    ^?  number | undefined\n * ```\n * @param options - The query options to tag with the type from `queryFn`.\n * @returns The tagged query options.\n * @public\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  queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\n/**\n * Allows to share and re-use query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n *\n * **Example**\n *\n * ```ts\n *  const { queryKey } = queryOptions({\n *     queryKey: ['key'],\n *     queryFn: () => Promise.resolve(5),\n *     //  ^?  Promise<number>\n *   })\n *\n *   const queryClient = new QueryClient()\n *   const data = queryClient.getQueryData(queryKey)\n *   //    ^?  number | undefined\n * ```\n * @param options - The query options to tag with the type from `queryFn`.\n * @returns The tagged query options.\n * @public\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  queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\n/**\n * Allows to share and re-use query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n *\n * **Example**\n *\n * ```ts\n *  const { queryKey } = queryOptions({\n *     queryKey: ['key'],\n *     queryFn: () => Promise.resolve(5),\n *     //  ^?  Promise<number>\n *   })\n *\n *   const queryClient = new QueryClient()\n *   const data = queryClient.getQueryData(queryKey)\n *   //    ^?  number | undefined\n * ```\n * @param options - The query options to tag with the type from `queryFn`.\n * @returns The tagged query options.\n * @public\n */\nexport function queryOptions(options: unknown) {\n  return options\n}\n"],"names":[],"mappings":"AA+KO,SAAS,aAAa,SAAkB;AACtC,SAAA;AACT;"}

package/dist/signal-proxy.mjs

@@ -0,0 +1,29 @@
+import { untracked, computed } from "@angular/core";
+function signalProxy(inputSignal) {
+  const internalState = {};
+  return new Proxy(internalState, {
+    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
+      };
+    }
+  });
+}
+export {
+  signalProxy
+};
+//# sourceMappingURL=signal-proxy.mjs.map

package/dist/signal-proxy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-proxy.mjs","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"],"names":[],"mappings":";AAaO,SAAS,YACd,aACA;AACA,QAAM,gBAAgB,CAAC;AAEhB,SAAA,IAAI,MAA4B,eAAe;AAAA,IACpD,IAAI,QAAQ,MAAM;AAEV,YAAA,gBAAgB,OAAO,IAAI;AACjC,UAAI,cAAsB,QAAA;AAG1B,YAAM,cAAc,UAAU,WAAW,EAAE,IAAI;AAC3C,UAAA,OAAO,gBAAgB,WAAmB,QAAA;AAItC,aAAA,OAAO,IAAI,IAAI,SAAS,MAAM,YAAY,EAAE,IAAI,CAAC;AAAA,IAC3D;AAAA,IACA,IAAI,GAAG,MAAM;AACX,aAAO,CAAC,CAAC,UAAU,WAAW,EAAE,IAAI;AAAA,IACtC;AAAA,IACA,UAAU;AACR,aAAO,QAAQ,QAAQ,UAAU,WAAW,CAAC;AAAA,IAC/C;AAAA,IACA,2BAA2B;AAClB,aAAA;AAAA,QACL,YAAY;AAAA,QACZ,cAAc;AAAA,MAChB;AAAA,IAAA;AAAA,EACF,CACD;AACH;"}

package/dist-ts/eslint.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any[];
+export default _default;
+//# sourceMappingURL=eslint.config.d.ts.map

package/dist-ts/root.eslint.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any[];
+export default _default;
+//# sourceMappingURL=root.eslint.config.d.ts.map

package/dist-ts/src/__tests__/inject-infinite-query.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-infinite-query.test-d.d.ts.map

package/dist-ts/src/__tests__/inject-infinite-query.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-infinite-query.test.d.ts.map

package/dist-ts/src/__tests__/inject-is-fetching.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-is-fetching.test.d.ts.map

package/dist-ts/src/__tests__/inject-is-mutating.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-is-mutating.test.d.ts.map

package/dist-ts/src/__tests__/inject-mutation-state.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-mutation-state.test-d.d.ts.map

package/dist-ts/src/__tests__/inject-mutation-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-mutation-state.test.d.ts.map

package/dist-ts/src/__tests__/inject-mutation.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-mutation.test-d.d.ts.map

package/dist-ts/src/__tests__/inject-mutation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-mutation.test.d.ts.map

package/dist-ts/src/__tests__/inject-query.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-query.test-d.d.ts.map

package/dist-ts/src/__tests__/inject-query.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject-query.test.d.ts.map

package/dist-ts/src/__tests__/mutation-options.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mutation-options.test-d.d.ts.map

package/dist-ts/src/__tests__/provide-query-client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provide-query-client.test.d.ts.map

package/dist-ts/src/__tests__/provide-tanstack-query.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provide-tanstack-query.test.d.ts.map

package/dist-ts/src/__tests__/providers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=providers.test.d.ts.map

package/dist-ts/src/__tests__/query-options.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=query-options.test-d.d.ts.map

package/dist-ts/src/__tests__/signal-proxy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=signal-proxy.test.d.ts.map

package/dist-ts/src/__tests__/test-utils.d.ts

@@ -0,0 +1,16 @@
+import type { InputSignal, Signal } from '@angular/core';
+import type { ComponentFixture } from '@angular/core/testing';
+export declare const expectSignals: <T extends Record<string, any>>(obj: T, expected: Partial<{ [K in keyof T]: T[K] extends Signal<any> ? ReturnType<T[K]> : never; }>) => void;
+type ToSignalInputUpdatableMap<T> = {
+    [K in keyof T as T[K] extends InputSignal<any> ? K : never]: T[K] extends InputSignal<infer Value> ? Value : never;
+};
+/**
+ * Set required signal input value to component fixture
+ * @see https://github.com/angular/angular/issues/54013
+ */
+export declare function setSignalInputs<T extends NonNullable<unknown>>(component: T, inputs: ToSignalInputUpdatableMap<T>): void;
+export declare function setFixtureSignalInputs<T extends NonNullable<unknown>>(componentFixture: ComponentFixture<T>, inputs: ToSignalInputUpdatableMap<T>, options?: {
+    detectChanges: boolean;
+}): void;
+export {};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist-ts/src/create-base-query.d.ts

@@ -0,0 +1,9 @@
+import type { QueryKey, QueryObserver, QueryObserverResult } from '@tanstack/query-core';
+import type { CreateBaseQueryOptions } from './types';
+/**
+ * Base implementation for `injectQuery` and `injectInfiniteQuery`.
+ * @param optionsFn
+ * @param Observer
+ */
+export declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(optionsFn: () => CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver): import("./signal-proxy").MapToSignals<QueryObserverResult<TData, TError>>;
+//# sourceMappingURL=create-base-query.d.ts.map

package/dist-ts/src/index.d.ts

@@ -0,0 +1,27 @@
+export * from '@tanstack/query-core';
+export * from './types';
+export type { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, } from './query-options';
+export { queryOptions } from './query-options';
+export type { CreateMutationOptions } from './mutation-options';
+export { mutationOptions } from './mutation-options';
+export type { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, } from './infinite-query-options';
+export { infiniteQueryOptions } from './infinite-query-options';
+export type { InjectInfiniteQueryOptions } from './inject-infinite-query';
+export { injectInfiniteQuery } from './inject-infinite-query';
+export type { InjectIsFetchingOptions } from './inject-is-fetching';
+export { injectIsFetching } from './inject-is-fetching';
+export type { InjectIsMutatingOptions } from './inject-is-mutating';
+export { injectIsMutating } from './inject-is-mutating';
+export { injectIsRestoring, provideIsRestoring } from './inject-is-restoring';
+export type { InjectMutationOptions } from './inject-mutation';
+export { injectMutation } from './inject-mutation';
+export type { InjectMutationStateOptions } from './inject-mutation-state';
+export { injectMutationState } from './inject-mutation-state';
+export type { QueriesOptions, QueriesResults } from './inject-queries';
+export { injectQueries } from './inject-queries';
+export type { InjectQueryOptions } from './inject-query';
+export { injectQuery } from './inject-query';
+export { injectQueryClient } from './inject-query-client';
+export type { DeveloperToolsFeature, DevtoolsOptions, PersistQueryClientFeature, QueryFeature, QueryFeatureKind, QueryFeatures, } from './providers';
+export { provideQueryClient, provideTanStackQuery, queryFeature, queryFeatures, withDevtools, } from './providers';
+//# sourceMappingURL=index.d.ts.map

package/dist-ts/src/infinite-query-options.d.ts

@@ -0,0 +1,45 @@
+import type { DataTag, DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, SkipToken } from '@tanstack/query-core';
+import type { CreateInfiniteQueryOptions } from './types';
+export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData?: undefined | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
+};
+export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
+    queryFn?: Exclude<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken | undefined>;
+};
+export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) | undefined;
+};
+/**
+ * Allows to share and re-use infinite query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ * @param options - The infinite query options to tag with the type from `queryFn`.
+ * @returns The tagged infinite query options.
+ * @public
+ */
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+/**
+ * Allows to share and re-use infinite query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ * @param options - The infinite query options to tag with the type from `queryFn`.
+ * @returns The tagged infinite query options.
+ * @public
+ */
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+/**
+ * Allows to share and re-use infinite query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ * @param options - The infinite query options to tag with the type from `queryFn`.
+ * @returns The tagged infinite query options.
+ * @public
+ */
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+};
+//# sourceMappingURL=infinite-query-options.d.ts.map

package/dist-ts/src/inject-infinite-query.d.ts

@@ -0,0 +1,40 @@
+import { Injector } from '@angular/core';
+import type { DefaultError, InfiniteData, QueryKey } from '@tanstack/query-core';
+import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult, DefinedCreateInfiniteQueryResult } from './types';
+import type { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from './infinite-query-options';
+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;
+}
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * @param options - Additional configuration.
+ * @returns The infinite query result.
+ * @public
+ */
+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>;
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * @param options - Additional configuration.
+ * @returns The infinite query result.
+ * @public
+ */
+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>;
+/**
+ * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ * Infinite queries can additively "load more" data onto an existing set of data or "infinite scroll"
+ * @param injectInfiniteQueryFn - A function that returns infinite query options.
+ * @param options - Additional configuration.
+ * @returns The infinite query result.
+ * @public
+ */
+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>;
+//# sourceMappingURL=inject-infinite-query.d.ts.map

package/dist-ts/src/inject-is-fetching.d.ts

@@ -0,0 +1,23 @@
+import { Injector } from '@angular/core';
+import type { QueryFilters } from '@tanstack/query-core';
+import type { Signal } from '@angular/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;
+}
+/**
+ * Injects a signal that tracks the number of queries that your application is loading or
+ * fetching in the background.
+ *
+ * Can be used for app-wide loading indicators
+ * @param filters - The filters to apply to the query.
+ * @param options - Additional configuration
+ * @returns signal with number of loading or fetching queries.
+ * @public
+ */
+export declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
+//# sourceMappingURL=inject-is-fetching.d.ts.map

package/dist-ts/src/inject-is-mutating.d.ts

@@ -0,0 +1,22 @@
+import { Injector } from '@angular/core';
+import type { MutationFilters } from '@tanstack/query-core';
+import type { Signal } from '@angular/core';
+export interface InjectIsMutatingOptions {
+    /**
+     * The `Injector` in which to create the isMutating 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 mutations that your application is fetching.
+ *
+ * Can be used for app-wide loading indicators
+ * @param filters - The filters to apply to the query.
+ * @param options - Additional configuration
+ * @returns signal with number of fetching mutations.
+ * @public
+ */
+export declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
+//# sourceMappingURL=inject-is-mutating.d.ts.map

package/{src/inject-is-restoring.ts → dist-ts/src/inject-is-restoring.d.ts}

@@ -1,52 +1,26 @@
-import {
-  InjectionToken,
-  Injector,
-  assertInInjectionContext,
-  inject,
-  signal,
-} from '@angular/core'
-import type { Provider, Signal } from '@angular/core'
-
-const IS_RESTORING = new InjectionToken(
-  typeof ngDevMode === 'undefined' || ngDevMode
-    ? 'TANSTACK_QUERY_IS_RESTORING'
-    : '',
-  {
-    // Default value when not provided
-    factory: () => signal(false).asReadonly(),
-  },
-)
-
+import { Injector } from '@angular/core';
+import type { Provider, Signal } from '@angular/core';
 /**
  * The `Injector` in which to create the isRestoring signal.
  *
  * If this is not provided, the current injection context will be used instead (via `inject`).
  */
 interface InjectIsRestoringOptions {
-  injector?: Injector
+    injector?: Injector;
 }
-
 /**
  * Injects a signal that tracks whether a restore is currently in progress. {@link injectQuery} and friends also check this internally to avoid race conditions between the restore and initializing queries.
  * @param options - Options for injectIsRestoring.
  * @returns signal with boolean that indicates whether a restore is in progress.
  * @public
  */
-export function injectIsRestoring(options?: InjectIsRestoringOptions) {
-  !options?.injector && assertInInjectionContext(injectIsRestoring)
-  const injector = options?.injector ?? inject(Injector)
-  return injector.get(IS_RESTORING)
-}
-
+export declare function injectIsRestoring(options?: InjectIsRestoringOptions): Signal<boolean>;
 /**
  * Used by TanStack Query Angular persist client plugin to provide the signal that tracks the restore state
  * @param isRestoring - a readonly signal that returns a boolean
  * @returns Provider for the `isRestoring` signal
  * @public
  */
-export function provideIsRestoring(isRestoring: Signal<boolean>): Provider {
-  return {
-    provide: IS_RESTORING,
-    useValue: isRestoring,
-  }
-}
+export declare function provideIsRestoring(isRestoring: Signal<boolean>): Provider;
+export {};
+//# sourceMappingURL=inject-is-restoring.d.ts.map

package/dist-ts/src/inject-mutation-state.d.ts

@@ -0,0 +1,28 @@
+import { Injector } from '@angular/core';
+import type { Signal } from '@angular/core';
+import type { Mutation, MutationFilters, MutationState } from '@tanstack/query-core';
+type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+/**
+ * @public
+ */
+export interface InjectMutationStateOptions {
+    /**
+     * The `Injector` in which to create the mutation state signal.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+}
+/**
+ * Injects a signal that tracks the state of all mutations.
+ * @param injectMutationStateFn - A function that returns mutation state options.
+ * @param options - The Angular injector to use.
+ * @returns The signal that tracks the state of all mutations.
+ * @public
+ */
+export declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
+export {};
+//# sourceMappingURL=inject-mutation-state.d.ts.map

package/dist-ts/src/inject-mutation.d.ts

@@ -0,0 +1,23 @@
+import { Injector } from '@angular/core';
+import type { DefaultError } from '@tanstack/query-core';
+import type { CreateMutationResult } from './types';
+import type { CreateMutationOptions } from './mutation-options';
+export interface InjectMutationOptions {
+    /**
+     * The `Injector` in which to create the mutation.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+}
+/**
+ * Injects a mutation: an imperative function that can be invoked which typically performs server side effects.
+ *
+ * Unlike queries, mutations are not run automatically.
+ * @param injectMutationFn - A function that returns mutation options.
+ * @param options - Additional configuration
+ * @returns The mutation.
+ * @public
+ */
+export declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TContext>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TContext>;
+//# sourceMappingURL=inject-mutation.d.ts.map