@tanstack/angular-query-experimental 5.82.0 → 5.83.1

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

@@ -0,0 +1,8 @@
+import { QueryKey, QueryObserver, QueryObserverResult } from '@tanstack/query-core';
+import { CreateBaseQueryOptions } from './types.js';
+/**
+ * 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.js').MapToSignals<QueryObserverResult<TData, TError>>;

package/dist/create-base-query.mjs

@@ -0,0 +1,74 @@
+import { inject, NgZone, computed, signal, effect, untracked, VERSION } from "@angular/core";
+import { QueryClient, notifyManager, shouldThrowError } from "@tanstack/query-core";
+import { signalProxy } from "./signal-proxy.mjs";
+import { injectIsRestoring } from "./inject-is-restoring.mjs";
+function createBaseQuery(optionsFn, Observer) {
+  const ngZone = inject(NgZone);
+  const queryClient = inject(QueryClient);
+  const isRestoring = injectIsRestoring();
+  const defaultedOptionsSignal = computed(() => {
+    const defaultedOptions = queryClient.defaultQueryOptions(optionsFn());
+    defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+    return defaultedOptions;
+  });
+  const observerSignal = (() => {
+    let instance = null;
+    return computed(() => {
+      return instance || (instance = new Observer(queryClient, defaultedOptionsSignal()));
+    });
+  })();
+  const optimisticResultSignal = computed(
+    () => observerSignal().getOptimisticResult(defaultedOptionsSignal())
+  );
+  const resultFromSubscriberSignal = signal(null);
+  effect(
+    (onCleanup) => {
+      const observer = observerSignal();
+      const defaultedOptions = defaultedOptionsSignal();
+      untracked(() => {
+        observer.setOptions(defaultedOptions);
+      });
+      onCleanup(() => {
+        ngZone.run(() => resultFromSubscriberSignal.set(null));
+      });
+    },
+    {
+      // Set allowSignalWrites to support Angular < v19
+      // Set to undefined to avoid warning on newer versions
+      allowSignalWrites: VERSION.major < "19" || void 0
+    }
+  );
+  effect((onCleanup) => {
+    const observer = observerSignal();
+    const unsubscribe = isRestoring() ? () => void 0 : untracked(
+      () => ngZone.runOutsideAngular(
+        () => observer.subscribe(
+          notifyManager.batchCalls((state) => {
+            ngZone.run(() => {
+              if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
+                state.error,
+                observer.getCurrentQuery()
+              ])) {
+                ngZone.onError.emit(state.error);
+                throw state.error;
+              }
+              resultFromSubscriberSignal.set(state);
+            });
+          })
+        )
+      )
+    );
+    onCleanup(unsubscribe);
+  });
+  return signalProxy(
+    computed(() => {
+      const subscriberResult = resultFromSubscriberSignal();
+      const optimisticResult = optimisticResultSignal();
+      return subscriberResult ?? optimisticResult;
+    })
+  );
+}
+export {
+  createBaseQuery
+};
+//# sourceMappingURL=create-base-query.mjs.map

package/dist/create-base-query.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-base-query.mjs","sources":["../src/create-base-query.ts"],"sourcesContent":["import {\n  NgZone,\n  VERSION,\n  computed,\n  effect,\n  inject,\n  signal,\n  untracked,\n} from '@angular/core'\nimport {\n  QueryClient,\n  notifyManager,\n  shouldThrowError,\n} from '@tanstack/query-core'\nimport { signalProxy } from './signal-proxy'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport type {\n  QueryKey,\n  QueryObserver,\n  QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { CreateBaseQueryOptions } from './types'\n\n/**\n * Base implementation for `injectQuery` and `injectInfiniteQuery`.\n * @param optionsFn\n * @param Observer\n */\nexport function createBaseQuery<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  optionsFn: () => CreateBaseQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  Observer: typeof QueryObserver,\n) {\n  const ngZone = inject(NgZone)\n  const queryClient = inject(QueryClient)\n  const isRestoring = injectIsRestoring()\n\n  /**\n   * Signal that has the default options from query client applied\n   * computed() is used so signals can be inserted into the options\n   * making it reactive. Wrapping options in a function ensures embedded expressions\n   * are preserved and can keep being applied after signal changes\n   */\n  const defaultedOptionsSignal = computed(() => {\n    const defaultedOptions = queryClient.defaultQueryOptions(optionsFn())\n    defaultedOptions._optimisticResults = isRestoring()\n      ? 'isRestoring'\n      : 'optimistic'\n    return defaultedOptions\n  })\n\n  const observerSignal = (() => {\n    let instance: QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    > | null = null\n\n    return computed(() => {\n      return (instance ||= new Observer(queryClient, defaultedOptionsSignal()))\n    })\n  })()\n\n  const optimisticResultSignal = computed(() =>\n    observerSignal().getOptimisticResult(defaultedOptionsSignal()),\n  )\n\n  const resultFromSubscriberSignal = signal<QueryObserverResult<\n    TData,\n    TError\n  > | null>(null)\n\n  effect(\n    (onCleanup) => {\n      const observer = observerSignal()\n      const defaultedOptions = defaultedOptionsSignal()\n\n      untracked(() => {\n        observer.setOptions(defaultedOptions)\n      })\n      onCleanup(() => {\n        ngZone.run(() => resultFromSubscriberSignal.set(null))\n      })\n    },\n    {\n      // Set allowSignalWrites to support Angular < v19\n      // Set to undefined to avoid warning on newer versions\n      allowSignalWrites: VERSION.major < '19' || undefined,\n    },\n  )\n\n  effect((onCleanup) => {\n    // observer.trackResult is not used as this optimization is not needed for Angular\n    const observer = observerSignal()\n    const unsubscribe = isRestoring()\n      ? () => undefined\n      : untracked(() =>\n          ngZone.runOutsideAngular(() =>\n            observer.subscribe(\n              notifyManager.batchCalls((state) => {\n                ngZone.run(() => {\n                  if (\n                    state.isError &&\n                    !state.isFetching &&\n                    shouldThrowError(observer.options.throwOnError, [\n                      state.error,\n                      observer.getCurrentQuery(),\n                    ])\n                  ) {\n                    ngZone.onError.emit(state.error)\n                    throw state.error\n                  }\n                  resultFromSubscriberSignal.set(state)\n                })\n              }),\n            ),\n          ),\n        )\n    onCleanup(unsubscribe)\n  })\n\n  return signalProxy(\n    computed(() => {\n      const subscriberResult = resultFromSubscriberSignal()\n      const optimisticResult = optimisticResultSignal()\n      return subscriberResult ?? optimisticResult\n    }),\n  )\n}\n"],"names":[],"mappings":";;;;AA4BgB,SAAA,gBAOd,WAOA,UACA;AACM,QAAA,SAAS,OAAO,MAAM;AACtB,QAAA,cAAc,OAAO,WAAW;AACtC,QAAM,cAAc,kBAAkB;AAQhC,QAAA,yBAAyB,SAAS,MAAM;AAC5C,UAAM,mBAAmB,YAAY,oBAAoB,UAAA,CAAW;AACnD,qBAAA,qBAAqB,YAAY,IAC9C,gBACA;AACG,WAAA;AAAA,EAAA,CACR;AAED,QAAM,kBAAkB,MAAM;AAC5B,QAAI,WAMO;AAEX,WAAO,SAAS,MAAM;AACpB,aAAQ,wBAAa,IAAI,SAAS,aAAa,wBAAwB;AAAA,IAAA,CACxE;AAAA,EAAA,GACA;AAEH,QAAM,yBAAyB;AAAA,IAAS,MACtC,eAAA,EAAiB,oBAAoB,uBAAwB,CAAA;AAAA,EAC/D;AAEM,QAAA,6BAA6B,OAGzB,IAAI;AAEd;AAAA,IACE,CAAC,cAAc;AACb,YAAM,WAAW,eAAe;AAChC,YAAM,mBAAmB,uBAAuB;AAEhD,gBAAU,MAAM;AACd,iBAAS,WAAW,gBAAgB;AAAA,MAAA,CACrC;AACD,gBAAU,MAAM;AACd,eAAO,IAAI,MAAM,2BAA2B,IAAI,IAAI,CAAC;AAAA,MAAA,CACtD;AAAA,IACH;AAAA,IACA;AAAA;AAAA;AAAA,MAGE,mBAAmB,QAAQ,QAAQ,QAAQ;AAAA,IAAA;AAAA,EAE/C;AAEA,SAAO,CAAC,cAAc;AAEpB,UAAM,WAAW,eAAe;AAChC,UAAM,cAAc,gBAChB,MAAM,SACN;AAAA,MAAU,MACR,OAAO;AAAA,QAAkB,MACvB,SAAS;AAAA,UACP,cAAc,WAAW,CAAC,UAAU;AAClC,mBAAO,IAAI,MAAM;AAEb,kBAAA,MAAM,WACN,CAAC,MAAM,cACP,iBAAiB,SAAS,QAAQ,cAAc;AAAA,gBAC9C,MAAM;AAAA,gBACN,SAAS,gBAAgB;AAAA,cAAA,CAC1B,GACD;AACO,uBAAA,QAAQ,KAAK,MAAM,KAAK;AAC/B,sBAAM,MAAM;AAAA,cAAA;AAEd,yCAA2B,IAAI,KAAK;AAAA,YAAA,CACrC;AAAA,UACF,CAAA;AAAA,QAAA;AAAA,MACH;AAAA,IAEJ;AACJ,cAAU,WAAW;AAAA,EAAA,CACtB;AAEM,SAAA;AAAA,IACL,SAAS,MAAM;AACb,YAAM,mBAAmB,2BAA2B;AACpD,YAAM,mBAAmB,uBAAuB;AAChD,aAAO,oBAAoB;AAAA,IAC5B,CAAA;AAAA,EACH;AACF;"}

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -0,0 +1,35 @@
+export * from "@tanstack/query-core";
+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 { injectQueries } from "./inject-queries.mjs";
+import { injectQuery } from "./inject-query.mjs";
+import { injectQueryClient } from "./inject-query-client.mjs";
+import { provideQueryClient, provideTanStackQuery, queryFeature, queryFeatures, withDevtools } from "./providers.mjs";
+export {
+  infiniteQueryOptions,
+  injectInfiniteQuery,
+  injectIsFetching,
+  injectIsMutating,
+  injectIsRestoring,
+  injectMutation,
+  injectMutationState,
+  injectQueries,
+  injectQuery,
+  injectQueryClient,
+  mutationOptions,
+  provideIsRestoring,
+  provideQueryClient,
+  provideTanStackQuery,
+  queryFeature,
+  queryFeatures,
+  queryOptions,
+  withDevtools
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

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

@@ -0,0 +1,44 @@
+import { DataTag, DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, SkipToken } from '@tanstack/query-core';
+import { CreateInfiniteQueryOptions } from './types.js';
+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>;
+};

package/dist/infinite-query-options.mjs

@@ -0,0 +1,7 @@
+function infiniteQueryOptions(options) {
+  return options;
+}
+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","sources":["../src/infinite-query-options.ts"],"sourcesContent":["import type {\n  DataTag,\n  DefaultError,\n  InfiniteData,\n  InitialDataFunction,\n  NonUndefinedGuard,\n  OmitKeyof,\n  QueryKey,\n  SkipToken,\n} from '@tanstack/query-core'\nimport type { CreateInfiniteQueryOptions } from './types'\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  initialData?:\n    | undefined\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | InitialDataFunction<\n        NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n      >\n}\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  queryFn?: Exclude<\n    CreateInfiniteQueryOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >['queryFn'],\n    SkipToken | undefined\n  >\n}\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  initialData:\n    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n    | undefined\n}\n\n/**\n * Allows to share and re-use infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n * @public\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  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\n/**\n * Allows to share and re-use infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n * @public\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  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\n/**\n * Allows to share and re-use infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n * @public\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  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\n/**\n * Allows to share and re-use infinite query options in a type-safe way.\n *\n * The `queryKey` will be tagged with the type from `queryFn`.\n * @param options - The infinite query options to tag with the type from `queryFn`.\n * @returns The tagged infinite query options.\n * @public\n */\nexport function infiniteQueryOptions(options: unknown) {\n  return options\n}\n"],"names":[],"mappings":"AAwLO,SAAS,qBAAqB,SAAkB;AAC9C,SAAA;AACT;"}

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

@@ -0,0 +1,39 @@
+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;
+}
+/**
+ * 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>;

package/dist/inject-infinite-query.mjs

@@ -0,0 +1,18 @@
+import { InfiniteQueryObserver } from "@tanstack/query-core";
+import { assertInInjectionContext, inject, Injector, runInInjectionContext } from "@angular/core";
+import { createBaseQuery } from "./create-base-query.mjs";
+function injectInfiniteQuery(injectInfiniteQueryFn, options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectInfiniteQuery);
+  const injector = (options == null ? void 0 : options.injector) ?? inject(Injector);
+  return runInInjectionContext(
+    injector,
+    () => createBaseQuery(
+      injectInfiniteQueryFn,
+      InfiniteQueryObserver
+    )
+  );
+}
+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","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 * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n * @public\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 unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n * @public\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 * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n * @public\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\n/**\n * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n * Infinite queries can additively \"load more\" data onto an existing set of data or \"infinite scroll\"\n * @param injectInfiniteQueryFn - A function that returns infinite query options.\n * @param options - Additional configuration.\n * @returns The infinite query result.\n * @public\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"],"names":[],"mappings":";;;AAoHgB,SAAA,oBACd,uBACA,SACA;AACC,IAAA,mCAAS,aAAY,yBAAyB,mBAAmB;AAClE,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AAC9C,SAAA;AAAA,IAAsB;AAAA,IAAU,MACrC;AAAA,MACE;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ;AACF;"}

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

@@ -0,0 +1,21 @@
+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;
+}
+/**
+ * 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>;

package/dist/inject-is-fetching.mjs

@@ -0,0 +1,31 @@
+import { assertInInjectionContext, inject, Injector, DestroyRef, NgZone, signal } from "@angular/core";
+import { QueryClient, notifyManager } from "@tanstack/query-core";
+function injectIsFetching(filters, options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectIsFetching);
+  const injector = (options == null ? void 0 : 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;
+}
+export {
+  injectIsFetching
+};
+//# sourceMappingURL=inject-is-fetching.mjs.map

package/dist/inject-is-fetching.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-fetching.mjs","sources":["../src/inject-is-fetching.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  inject,\n  signal,\n} from '@angular/core'\nimport { QueryClient, notifyManager } from '@tanstack/query-core'\nimport type { QueryFilters } from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\n\nexport interface InjectIsFetchingOptions {\n  /**\n   * The `Injector` in which to create the isFetching signal.\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 * Injects a signal that tracks the number of queries that your application is loading or\n * fetching in the background.\n *\n * Can be used for app-wide loading indicators\n * @param filters - The filters to apply to the query.\n * @param options - Additional configuration\n * @returns signal with number of loading or fetching queries.\n * @public\n */\nexport function injectIsFetching(\n  filters?: QueryFilters,\n  options?: InjectIsFetchingOptions,\n): Signal<number> {\n  !options?.injector && assertInInjectionContext(injectIsFetching)\n  const injector = options?.injector ?? inject(Injector)\n  const destroyRef = injector.get(DestroyRef)\n  const ngZone = injector.get(NgZone)\n  const queryClient = injector.get(QueryClient)\n\n  const cache = queryClient.getQueryCache()\n  // isFetching is the prev value initialized on mount *\n  let isFetching = queryClient.isFetching(filters)\n\n  const result = signal(isFetching)\n\n  const unsubscribe = ngZone.runOutsideAngular(() =>\n    cache.subscribe(\n      notifyManager.batchCalls(() => {\n        const newIsFetching = queryClient.isFetching(filters)\n        if (isFetching !== newIsFetching) {\n          // * and update with each change\n          isFetching = newIsFetching\n          ngZone.run(() => {\n            result.set(isFetching)\n          })\n        }\n      }),\n    ),\n  )\n\n  destroyRef.onDestroy(unsubscribe)\n\n  return result\n}\n"],"names":[],"mappings":";;AA+BgB,SAAA,iBACd,SACA,SACgB;AACf,IAAA,mCAAS,aAAY,yBAAyB,gBAAgB;AAC/D,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AAC/C,QAAA,aAAa,SAAS,IAAI,UAAU;AACpC,QAAA,SAAS,SAAS,IAAI,MAAM;AAC5B,QAAA,cAAc,SAAS,IAAI,WAAW;AAEtC,QAAA,QAAQ,YAAY,cAAc;AAEpC,MAAA,aAAa,YAAY,WAAW,OAAO;AAEzC,QAAA,SAAS,OAAO,UAAU;AAEhC,QAAM,cAAc,OAAO;AAAA,IAAkB,MAC3C,MAAM;AAAA,MACJ,cAAc,WAAW,MAAM;AACvB,cAAA,gBAAgB,YAAY,WAAW,OAAO;AACpD,YAAI,eAAe,eAAe;AAEnB,uBAAA;AACb,iBAAO,IAAI,MAAM;AACf,mBAAO,IAAI,UAAU;AAAA,UAAA,CACtB;AAAA,QAAA;AAAA,MAEJ,CAAA;AAAA,IAAA;AAAA,EAEL;AAEA,aAAW,UAAU,WAAW;AAEzB,SAAA;AACT;"}

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

@@ -0,0 +1,20 @@
+import { Injector, Signal } from '@angular/core';
+import { MutationFilters } from '@tanstack/query-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>;

package/dist/inject-is-mutating.mjs

@@ -0,0 +1,31 @@
+import { assertInInjectionContext, inject, Injector, DestroyRef, NgZone, signal } from "@angular/core";
+import { QueryClient, notifyManager } from "@tanstack/query-core";
+function injectIsMutating(filters, options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectIsMutating);
+  const injector = (options == null ? void 0 : options.injector) ?? inject(Injector);
+  const destroyRef = injector.get(DestroyRef);
+  const ngZone = injector.get(NgZone);
+  const queryClient = injector.get(QueryClient);
+  const cache = queryClient.getMutationCache();
+  let isMutating = queryClient.isMutating(filters);
+  const result = signal(isMutating);
+  const unsubscribe = ngZone.runOutsideAngular(
+    () => cache.subscribe(
+      notifyManager.batchCalls(() => {
+        const newIsMutating = queryClient.isMutating(filters);
+        if (isMutating !== newIsMutating) {
+          isMutating = newIsMutating;
+          ngZone.run(() => {
+            result.set(isMutating);
+          });
+        }
+      })
+    )
+  );
+  destroyRef.onDestroy(unsubscribe);
+  return result;
+}
+export {
+  injectIsMutating
+};
+//# sourceMappingURL=inject-is-mutating.mjs.map

package/dist/inject-is-mutating.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-mutating.mjs","sources":["../src/inject-is-mutating.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  inject,\n  signal,\n} from '@angular/core'\nimport { QueryClient, notifyManager } from '@tanstack/query-core'\nimport type { MutationFilters } from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\n\nexport interface InjectIsMutatingOptions {\n  /**\n   * The `Injector` in which to create the isMutating signal.\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 * Injects a signal that tracks the number of mutations that your application is fetching.\n *\n * Can be used for app-wide loading indicators\n * @param filters - The filters to apply to the query.\n * @param options - Additional configuration\n * @returns signal with number of fetching mutations.\n * @public\n */\nexport function injectIsMutating(\n  filters?: MutationFilters,\n  options?: InjectIsMutatingOptions,\n): Signal<number> {\n  !options?.injector && assertInInjectionContext(injectIsMutating)\n  const injector = options?.injector ?? inject(Injector)\n  const destroyRef = injector.get(DestroyRef)\n  const ngZone = injector.get(NgZone)\n  const queryClient = injector.get(QueryClient)\n\n  const cache = queryClient.getMutationCache()\n  // isMutating is the prev value initialized on mount *\n  let isMutating = queryClient.isMutating(filters)\n\n  const result = signal(isMutating)\n\n  const unsubscribe = ngZone.runOutsideAngular(() =>\n    cache.subscribe(\n      notifyManager.batchCalls(() => {\n        const newIsMutating = queryClient.isMutating(filters)\n        if (isMutating !== newIsMutating) {\n          // * and update with each change\n          isMutating = newIsMutating\n          ngZone.run(() => {\n            result.set(isMutating)\n          })\n        }\n      }),\n    ),\n  )\n\n  destroyRef.onDestroy(unsubscribe)\n\n  return result\n}\n"],"names":[],"mappings":";;AA8BgB,SAAA,iBACd,SACA,SACgB;AACf,IAAA,mCAAS,aAAY,yBAAyB,gBAAgB;AAC/D,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AAC/C,QAAA,aAAa,SAAS,IAAI,UAAU;AACpC,QAAA,SAAS,SAAS,IAAI,MAAM;AAC5B,QAAA,cAAc,SAAS,IAAI,WAAW;AAEtC,QAAA,QAAQ,YAAY,iBAAiB;AAEvC,MAAA,aAAa,YAAY,WAAW,OAAO;AAEzC,QAAA,SAAS,OAAO,UAAU;AAEhC,QAAM,cAAc,OAAO;AAAA,IAAkB,MAC3C,MAAM;AAAA,MACJ,cAAc,WAAW,MAAM;AACvB,cAAA,gBAAgB,YAAY,WAAW,OAAO;AACpD,YAAI,eAAe,eAAe;AAEnB,uBAAA;AACb,iBAAO,IAAI,MAAM;AACf,mBAAO,IAAI,UAAU;AAAA,UAAA,CACtB;AAAA,QAAA;AAAA,MAEJ,CAAA;AAAA,IAAA;AAAA,EAEL;AAEA,aAAW,UAAU,WAAW;AAEzB,SAAA;AACT;"}

package/dist/inject-is-restoring.d.ts

@@ -0,0 +1,24 @@
+import { Injector, 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;
+}
+/**
+ * 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 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 declare function provideIsRestoring(isRestoring: Signal<boolean>): Provider;
+export {};

package/dist/inject-is-restoring.mjs

@@ -0,0 +1,24 @@
+import { assertInInjectionContext, inject, Injector, InjectionToken, 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()
+  }
+);
+function injectIsRestoring(options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectIsRestoring);
+  const injector = (options == null ? void 0 : options.injector) ?? inject(Injector);
+  return injector.get(IS_RESTORING);
+}
+function provideIsRestoring(isRestoring) {
+  return {
+    provide: IS_RESTORING,
+    useValue: isRestoring
+  };
+}
+export {
+  injectIsRestoring,
+  provideIsRestoring
+};
+//# sourceMappingURL=inject-is-restoring.mjs.map

package/dist/inject-is-restoring.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-restoring.mjs","sources":["../src/inject-is-restoring.ts"],"sourcesContent":["import {\n  InjectionToken,\n  Injector,\n  assertInInjectionContext,\n  inject,\n  signal,\n} from '@angular/core'\nimport type { Provider, Signal } from '@angular/core'\n\nconst IS_RESTORING = new InjectionToken(\n  typeof ngDevMode === 'undefined' || ngDevMode\n    ? 'TANSTACK_QUERY_IS_RESTORING'\n    : '',\n  {\n    // Default value when not provided\n    factory: () => signal(false).asReadonly(),\n  },\n)\n\n/**\n * The `Injector` in which to create the isRestoring signal.\n *\n * If this is not provided, the current injection context will be used instead (via `inject`).\n */\ninterface InjectIsRestoringOptions {\n  injector?: Injector\n}\n\n/**\n * 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.\n * @param options - Options for injectIsRestoring.\n * @returns signal with boolean that indicates whether a restore is in progress.\n * @public\n */\nexport function injectIsRestoring(options?: InjectIsRestoringOptions) {\n  !options?.injector && assertInInjectionContext(injectIsRestoring)\n  const injector = options?.injector ?? inject(Injector)\n  return injector.get(IS_RESTORING)\n}\n\n/**\n * Used by TanStack Query Angular persist client plugin to provide the signal that tracks the restore state\n * @param isRestoring - a readonly signal that returns a boolean\n * @returns Provider for the `isRestoring` signal\n * @public\n */\nexport function provideIsRestoring(isRestoring: Signal<boolean>): Provider {\n  return {\n    provide: IS_RESTORING,\n    useValue: isRestoring,\n  }\n}\n"],"names":[],"mappings":";AASA,MAAM,eAAe,IAAI;AAAA,EACvB,OAAO,cAAc,eAAe,YAChC,gCACA;AAAA,EACJ;AAAA;AAAA,IAEE,SAAS,MAAM,OAAO,KAAK,EAAE,WAAW;AAAA,EAAA;AAE5C;AAiBO,SAAS,kBAAkB,SAAoC;AACnE,IAAA,mCAAS,aAAY,yBAAyB,iBAAiB;AAChE,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AAC9C,SAAA,SAAS,IAAI,YAAY;AAClC;AAQO,SAAS,mBAAmB,aAAwC;AAClE,SAAA;AAAA,IACL,SAAS;AAAA,IACT,UAAU;AAAA,EACZ;AACF;"}

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

@@ -0,0 +1,26 @@
+import { Injector, Signal } from '@angular/core';
+import { 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 {};

package/dist/inject-mutation-state.mjs

@@ -0,0 +1,51 @@
+import { assertInInjectionContext, inject, Injector, DestroyRef, NgZone, computed, signal } from "@angular/core";
+import { QueryClient, notifyManager, replaceEqualDeep } from "@tanstack/query-core";
+function getResult(mutationCache, options) {
+  return mutationCache.findAll(options.filters).map(
+    (mutation) => options.select ? options.select(mutation) : mutation.state
+  );
+}
+function injectMutationState(injectMutationStateFn = () => ({}), options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectMutationState);
+  const injector = (options == null ? void 0 : options.injector) ?? inject(Injector);
+  const destroyRef = injector.get(DestroyRef);
+  const ngZone = injector.get(NgZone);
+  const queryClient = injector.get(QueryClient);
+  const mutationCache = queryClient.getMutationCache();
+  const resultFromOptionsSignal = computed(() => {
+    return [
+      getResult(mutationCache, injectMutationStateFn()),
+      performance.now()
+    ];
+  });
+  const resultFromSubscriberSignal = signal(
+    null
+  );
+  const effectiveResultSignal = computed(() => {
+    const optionsResult = resultFromOptionsSignal();
+    const subscriberResult = resultFromSubscriberSignal();
+    return subscriberResult && subscriberResult[1] > optionsResult[1] ? subscriberResult[0] : optionsResult[0];
+  });
+  const unsubscribe = ngZone.runOutsideAngular(
+    () => mutationCache.subscribe(
+      notifyManager.batchCalls(() => {
+        const [lastResult] = effectiveResultSignal();
+        const nextResult = replaceEqualDeep(
+          lastResult,
+          getResult(mutationCache, injectMutationStateFn())
+        );
+        if (lastResult !== nextResult) {
+          ngZone.run(() => {
+            resultFromSubscriberSignal.set([nextResult, performance.now()]);
+          });
+        }
+      })
+    )
+  );
+  destroyRef.onDestroy(unsubscribe);
+  return effectiveResultSignal;
+}
+export {
+  injectMutationState
+};
+//# sourceMappingURL=inject-mutation-state.mjs.map

package/dist/inject-mutation-state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-mutation-state.mjs","sources":["../src/inject-mutation-state.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  inject,\n  signal,\n} from '@angular/core'\nimport {\n  QueryClient,\n  notifyManager,\n  replaceEqualDeep,\n} from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\nimport type {\n  Mutation,\n  MutationCache,\n  MutationFilters,\n  MutationState,\n} from '@tanstack/query-core'\n\ntype MutationStateOptions<TResult = MutationState> = {\n  filters?: MutationFilters\n  select?: (mutation: Mutation) => TResult\n}\n\n/**\n *\n * @param mutationCache\n * @param options\n */\nfunction getResult<TResult = MutationState>(\n  mutationCache: MutationCache,\n  options: MutationStateOptions<TResult>,\n): Array<TResult> {\n  return mutationCache\n    .findAll(options.filters)\n    .map(\n      (mutation): TResult =>\n        (options.select ? options.select(mutation) : mutation.state) as TResult,\n    )\n}\n\n/**\n * @public\n */\nexport interface InjectMutationStateOptions {\n  /**\n   * The `Injector` in which to create the mutation state signal.\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 * Injects a signal that tracks the state of all mutations.\n * @param injectMutationStateFn - A function that returns mutation state options.\n * @param options - The Angular injector to use.\n * @returns The signal that tracks the state of all mutations.\n * @public\n */\nexport function injectMutationState<TResult = MutationState>(\n  injectMutationStateFn: () => MutationStateOptions<TResult> = () => ({}),\n  options?: InjectMutationStateOptions,\n): Signal<Array<TResult>> {\n  !options?.injector && assertInInjectionContext(injectMutationState)\n  const injector = options?.injector ?? inject(Injector)\n  const destroyRef = injector.get(DestroyRef)\n  const ngZone = injector.get(NgZone)\n  const queryClient = injector.get(QueryClient)\n  const mutationCache = queryClient.getMutationCache()\n\n  /**\n   * Computed signal that gets result from mutation cache based on passed options\n   * First element is the result, second element is the time when the result was set\n   */\n  const resultFromOptionsSignal = computed(() => {\n    return [\n      getResult(mutationCache, injectMutationStateFn()),\n      performance.now(),\n    ] as const\n  })\n\n  /**\n   * Signal that contains result set by subscriber\n   * First element is the result, second element is the time when the result was set\n   */\n  const resultFromSubscriberSignal = signal<[Array<TResult>, number] | null>(\n    null,\n  )\n\n  /**\n   * Returns the last result by either subscriber or options\n   */\n  const effectiveResultSignal = computed(() => {\n    const optionsResult = resultFromOptionsSignal()\n    const subscriberResult = resultFromSubscriberSignal()\n    return subscriberResult && subscriberResult[1] > optionsResult[1]\n      ? subscriberResult[0]\n      : optionsResult[0]\n  })\n\n  const unsubscribe = ngZone.runOutsideAngular(() =>\n    mutationCache.subscribe(\n      notifyManager.batchCalls(() => {\n        const [lastResult] = effectiveResultSignal()\n        const nextResult = replaceEqualDeep(\n          lastResult,\n          getResult(mutationCache, injectMutationStateFn()),\n        )\n        if (lastResult !== nextResult) {\n          ngZone.run(() => {\n            resultFromSubscriberSignal.set([nextResult, performance.now()])\n          })\n        }\n      }),\n    ),\n  )\n\n  destroyRef.onDestroy(unsubscribe)\n\n  return effectiveResultSignal\n}\n"],"names":[],"mappings":";;AAgCA,SAAS,UACP,eACA,SACgB;AAChB,SAAO,cACJ,QAAQ,QAAQ,OAAO,EACvB;AAAA,IACC,CAAC,aACE,QAAQ,SAAS,QAAQ,OAAO,QAAQ,IAAI,SAAS;AAAA,EAC1D;AACJ;AAqBO,SAAS,oBACd,wBAA6D,OAAO,KACpE,SACwB;AACvB,IAAA,mCAAS,aAAY,yBAAyB,mBAAmB;AAClE,QAAM,YAAW,mCAAS,aAAY,OAAO,QAAQ;AAC/C,QAAA,aAAa,SAAS,IAAI,UAAU;AACpC,QAAA,SAAS,SAAS,IAAI,MAAM;AAC5B,QAAA,cAAc,SAAS,IAAI,WAAW;AACtC,QAAA,gBAAgB,YAAY,iBAAiB;AAM7C,QAAA,0BAA0B,SAAS,MAAM;AACtC,WAAA;AAAA,MACL,UAAU,eAAe,uBAAuB;AAAA,MAChD,YAAY,IAAI;AAAA,IAClB;AAAA,EAAA,CACD;AAMD,QAAM,6BAA6B;AAAA,IACjC;AAAA,EACF;AAKM,QAAA,wBAAwB,SAAS,MAAM;AAC3C,UAAM,gBAAgB,wBAAwB;AAC9C,UAAM,mBAAmB,2BAA2B;AAC7C,WAAA,oBAAoB,iBAAiB,CAAC,IAAI,cAAc,CAAC,IAC5D,iBAAiB,CAAC,IAClB,cAAc,CAAC;AAAA,EAAA,CACpB;AAED,QAAM,cAAc,OAAO;AAAA,IAAkB,MAC3C,cAAc;AAAA,MACZ,cAAc,WAAW,MAAM;AACvB,cAAA,CAAC,UAAU,IAAI,sBAAsB;AAC3C,cAAM,aAAa;AAAA,UACjB;AAAA,UACA,UAAU,eAAe,sBAAuB,CAAA;AAAA,QAClD;AACA,YAAI,eAAe,YAAY;AAC7B,iBAAO,IAAI,MAAM;AACf,uCAA2B,IAAI,CAAC,YAAY,YAAY,IAAK,CAAA,CAAC;AAAA,UAAA,CAC/D;AAAA,QAAA;AAAA,MAEJ,CAAA;AAAA,IAAA;AAAA,EAEL;AAEA,aAAW,UAAU,WAAW;AAEzB,SAAA;AACT;"}

package/dist/inject-mutation.d.ts

@@ -0,0 +1,22 @@
+import { Injector } from '@angular/core';
+import { DefaultError } from '@tanstack/query-core';
+import { CreateMutationResult } from './types.js';
+import { CreateMutationOptions } from './mutation-options.js';
+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>;