@tanstack/angular-query-experimental 5.103.1 → 5.103.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-fetching.mjs","names":[],"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 fetching in the\n * background (useful for app-wide loading indicators).\n *\n * @param filters - The {@link QueryFilters} to narrow down the matched queries.\n * @param options - Additional configuration\n * @returns A `Signal` with the number of queries that your application is currently loading or fetching in\n * the background.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts-fetching-indicator',\n *   template: `\n *     @if (isFetchingPosts()) {\n *       <span>Refreshing posts...</span>\n *     }\n *   `,\n * })\n * export class PostsFetchingIndicator {\n *   // How many queries matching the posts prefix are fetching?\n *   readonly isFetchingPosts = injectIsFetching({ queryKey: ['posts'] })\n * }\n * ```\n *\n * @example\n * A global loading indicator for any query fetching in the background, not just the ones on screen:\n * ```angular-ts\n * @Component({\n *   selector: 'global-loading-indicator',\n *   template: `\n *     @if (isFetching()) {\n *       <div>Queries are fetching in the background...</div>\n *     }\n *   `,\n * })\n * export class GlobalLoadingIndicator {\n *   readonly isFetching = injectIsFetching()\n * }\n * ```\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,iBACd,SACA,SACgB;CAChB,CAAC,SAAS,YAAY,yBAAyB,gBAAgB;CAC/D,MAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;CACrD,MAAM,aAAa,SAAS,IAAI,UAAU;CAC1C,MAAM,SAAS,SAAS,IAAI,MAAM;CAClC,MAAM,cAAc,SAAS,IAAI,WAAW;CAE5C,MAAM,QAAQ,YAAY,cAAc;CAExC,IAAI,aAAa,YAAY,WAAW,OAAO;CAE/C,MAAM,SAAS,OAAO,UAAU;CAEhC,MAAM,cAAc,OAAO,wBACzB,MAAM,UACJ,cAAc,iBAAiB;EAC7B,MAAM,gBAAgB,YAAY,WAAW,OAAO;EACpD,IAAI,eAAe,eAAe;GAEhC,aAAa;GACb,OAAO,UAAU;IACf,OAAO,IAAI,UAAU;GACvB,CAAC;EACH;CACF,CAAC,CACH,CACF;CAEA,WAAW,UAAU,WAAW;CAEhC,OAAO;AACT"}

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

@@ -1,12 +1,13 @@
-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;
+import { Injector, Signal } from "@angular/core";
+import { MutationFilters } from "@tanstack/query-core";
+//#region src/inject-is-mutating.d.ts
+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 currently has `pending`
@@ -32,4 +33,7 @@ export interface InjectIsMutatingOptions {
  * }
  * ```
  */
-export declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
+declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
+//#endregion
+export { InjectIsMutatingOptions, injectIsMutating };
+//# sourceMappingURL=inject-is-mutating.d.mts.map

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

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

package/dist/inject-is-mutating.mjs

@@ -0,0 +1,52 @@
+import { DestroyRef, Injector, NgZone, assertInInjectionContext, inject, signal } from "@angular/core";
+import { QueryClient, notifyManager } from "@tanstack/query-core";
+//#region src/inject-is-mutating.ts
+/**
+* Injects a signal that tracks the number of mutations that your application currently has `pending`
+* (useful for app-wide loading indicators).
+*
+* @param filters - The {@link MutationFilters} to narrow down the matched mutations.
+* @param options - Additional configuration
+* @returns A `Signal` with the number of mutations that your application currently has `pending`.
+*
+* @example
+* ```angular-ts
+* @Component({
+*   selector: 'posts-mutating-indicator',
+*   template: `
+*     @if (isMutatingPosts()) {
+*       <span>Saving posts...</span>
+*     }
+*   `,
+* })
+* export class PostsMutatingIndicator {
+*   // How many mutations matching the posts prefix are in progress?
+*   readonly isMutatingPosts = injectIsMutating({ mutationKey: ['posts'] })
+* }
+* ```
+*/
+function injectIsMutating(filters, options) {
+	!options?.injector && assertInInjectionContext(injectIsMutating);
+	const injector = 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.asReadonly();
+}
+//#endregion
+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","names":[],"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 currently has `pending`\n * (useful for app-wide loading indicators).\n *\n * @param filters - The {@link MutationFilters} to narrow down the matched mutations.\n * @param options - Additional configuration\n * @returns A `Signal` with the number of mutations that your application currently has `pending`.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts-mutating-indicator',\n *   template: `\n *     @if (isMutatingPosts()) {\n *       <span>Saving posts...</span>\n *     }\n *   `,\n * })\n * export class PostsMutatingIndicator {\n *   // How many mutations matching the posts prefix are in progress?\n *   readonly isMutatingPosts = injectIsMutating({ mutationKey: ['posts'] })\n * }\n * ```\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.asReadonly()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,iBACd,SACA,SACgB;CAChB,CAAC,SAAS,YAAY,yBAAyB,gBAAgB;CAC/D,MAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;CACrD,MAAM,aAAa,SAAS,IAAI,UAAU;CAC1C,MAAM,SAAS,SAAS,IAAI,MAAM;CAClC,MAAM,cAAc,SAAS,IAAI,WAAW;CAE5C,MAAM,QAAQ,YAAY,iBAAiB;CAE3C,IAAI,aAAa,YAAY,WAAW,OAAO;CAE/C,MAAM,SAAS,OAAO,UAAU;CAEhC,MAAM,cAAc,OAAO,wBACzB,MAAM,UACJ,cAAc,iBAAiB;EAC7B,MAAM,gBAAgB,YAAY,WAAW,OAAO;EACpD,IAAI,eAAe,eAAe;GAEhC,aAAa;GACb,OAAO,UAAU;IACf,OAAO,IAAI,UAAU;GACvB,CAAC;EACH;CACF,CAAC,CACH,CACF;CAEA,WAAW,UAAU,WAAW;CAEhC,OAAO,OAAO,WAAW;AAC3B"}

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

@@ -1,11 +1,12 @@
-import { Injector, Provider, Signal } from '@angular/core';
+import { Injector, Provider, Signal } from "@angular/core";
+//#region src/inject-is-restoring.d.ts
 interface InjectIsRestoringOptions {
-    /**
-     * The `Injector` to use to get the isRestoring signal.
-     *
-     * If this is not provided, the current injection context will be used instead (via `inject`).
-     */
-    injector?: Injector;
+  /**
+   * The `Injector` to use to get the isRestoring signal.
+   *
+   * If this is not provided, the current injection context will be used instead (via `inject`).
+   */
+  injector?: Injector;
 }
 /**
  * Injects a signal that tracks whether a restore (e.g. from a persisted client, wired up via
@@ -15,7 +16,7 @@ interface InjectIsRestoringOptions {
  * @returns A readonly `Signal<boolean>` — `true` while a restore is in progress, `false` otherwise (the
  * default when no `provideIsRestoring` provider is registered).
  */
-export declare function injectIsRestoring(options?: InjectIsRestoringOptions): Signal<boolean>;
+declare function injectIsRestoring(options?: InjectIsRestoringOptions): Signal<boolean>;
 /**
  * Registers a provider for the restore state read by `injectIsRestoring`. Wire this up wherever you drive a
  * restore yourself — e.g. a persist-client integration — so `injectQuery` and friends can defer subscribing
@@ -23,5 +24,7 @@ export declare function injectIsRestoring(options?: InjectIsRestoringOptions): S
  * @param isRestoring - A readonly `Signal<boolean>` that tracks the restore state.
  * @returns A provider for the `isRestoring` signal.
  */
-export declare function provideIsRestoring(isRestoring: Signal<boolean>): Provider;
-export {};
+declare function provideIsRestoring(isRestoring: Signal<boolean>): Provider;
+//#endregion
+export { injectIsRestoring, provideIsRestoring };
+//# sourceMappingURL=inject-is-restoring.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-restoring.d.mts","names":[],"sources":["../src/inject-is-restoring.ts"],"mappings":";;UAiBU;;;;;;EAMR,WAAW;;;;;;;;;;iBAWG,kBAAkB,UAAU,2BAAwB;;;;;;;;iBAapD,mBAAmB,aAAa,kBAAkB"}

package/dist/inject-is-restoring.mjs

@@ -0,0 +1,35 @@
+import { InjectionToken, Injector, assertInInjectionContext, inject, signal } from "@angular/core";
+//#region src/inject-is-restoring.ts
+/**
+* Internal token used to track isRestoring state, accessible in public API through `injectIsRestoring` and set via `provideIsRestoring`
+*/
+const IS_RESTORING = new InjectionToken("", { factory: () => signal(false).asReadonly() });
+/**
+* Injects a signal that tracks whether a restore (e.g. from a persisted client, wired up via
+* `provideIsRestoring`) is currently in progress. `injectQuery` and friends also check this internally to
+* avoid race conditions between the restore and initializing queries.
+* @param options - Additional configuration
+* @returns A readonly `Signal<boolean>` — `true` while a restore is in progress, `false` otherwise (the
+* default when no `provideIsRestoring` provider is registered).
+*/
+function injectIsRestoring(options) {
+	!options?.injector && assertInInjectionContext(injectIsRestoring);
+	return (options?.injector ?? inject(Injector)).get(IS_RESTORING);
+}
+/**
+* Registers a provider for the restore state read by `injectIsRestoring`. Wire this up wherever you drive a
+* restore yourself — e.g. a persist-client integration — so `injectQuery` and friends can defer subscribing
+* to their observer (avoiding a race with the restore) until the restore signal flips back to `false`.
+* @param isRestoring - A readonly `Signal<boolean>` that tracks the restore state.
+* @returns A provider for the `isRestoring` signal.
+*/
+function provideIsRestoring(isRestoring) {
+	return {
+		provide: IS_RESTORING,
+		useValue: isRestoring
+	};
+}
+//#endregion
+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","names":[],"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\n/**\n * Internal token used to track isRestoring state, accessible in public API through `injectIsRestoring` and set via `provideIsRestoring`\n */\nconst IS_RESTORING = new InjectionToken('', {\n  // Default value when not provided\n  factory: () => signal(false).asReadonly(),\n})\n\ninterface InjectIsRestoringOptions {\n  /**\n   * The `Injector` to use to get the isRestoring 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 whether a restore (e.g. from a persisted client, wired up via\n * `provideIsRestoring`) is currently in progress. `injectQuery` and friends also check this internally to\n * avoid race conditions between the restore and initializing queries.\n * @param options - Additional configuration\n * @returns A readonly `Signal<boolean>` — `true` while a restore is in progress, `false` otherwise (the\n * default when no `provideIsRestoring` provider is registered).\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 * Registers a provider for the restore state read by `injectIsRestoring`. Wire this up wherever you drive a\n * restore yourself — e.g. a persist-client integration — so `injectQuery` and friends can defer subscribing\n * to their observer (avoiding a race with the restore) until the restore signal flips back to `false`.\n * @param isRestoring - A readonly `Signal<boolean>` that tracks the restore state.\n * @returns A provider for the `isRestoring` signal.\n */\nexport function provideIsRestoring(isRestoring: Signal<boolean>): Provider {\n  return {\n    provide: IS_RESTORING,\n    useValue: isRestoring,\n  }\n}\n"],"mappings":";;;;;AAYA,MAAM,eAAe,IAAI,eAAe,IAAI,EAE1C,eAAe,OAAO,KAAK,CAAC,CAAC,WAAW,EAC1C,CAAC;;;;;;;;;AAmBD,SAAgB,kBAAkB,SAAoC;CACpE,CAAC,SAAS,YAAY,yBAAyB,iBAAiB;CAEhE,QADiB,SAAS,YAAY,OAAO,QAAQ,EAAA,CACrC,IAAI,YAAY;AAClC;;;;;;;;AASA,SAAgB,mBAAmB,aAAwC;CACzE,OAAO;EACL,SAAS;EACT,UAAU;CACZ;AACF"}

package/{inject-mutation-state.d.ts → dist/inject-mutation-state.d.mts}

@@ -1,16 +1,17 @@
-import { Injector, Signal } from '@angular/core';
-import { Mutation, MutationFilters, MutationState } from '@tanstack/query-core';
+import { Injector, Signal } from "@angular/core";
+import { Mutation, MutationFilters, MutationState } from "@tanstack/query-core";
+//#region src/inject-mutation-state.d.ts
 type MutationStateOptions<TResult = MutationState> = {
-    filters?: MutationFilters;
-    select?: (mutation: Mutation) => TResult;
+  filters?: MutationFilters;
+  select?: (mutation: Mutation) => TResult;
 };
-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;
+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 gives you access to all mutations in the `MutationCache`. You can pass `filters`
@@ -69,5 +70,7 @@ export interface InjectMutationStateOptions {
  * }
  * ```
  */
-export declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
-export {};
+declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
+//#endregion
+export { InjectMutationStateOptions, injectMutationState };
+//# sourceMappingURL=inject-mutation-state.d.mts.map

package/dist/inject-mutation-state.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-mutation-state.d.mts","names":[],"sources":["../src/inject-mutation-state.ts"],"mappings":";;;KAsBK,qBAAqB,UAAU;EAClC,UAAU;EACV,UAAU,UAAU,aAAa;;UAelB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DG,oBAAoB,UAAU,eAC5C,8BAA6B,qBAAqB,UAClD,UAAU,6BACT,OAAO,MAAM"}

package/dist/inject-mutation-state.mjs

@@ -0,0 +1,103 @@
+import { DestroyRef, Injector, NgZone, assertInInjectionContext, computed, inject, signal } from "@angular/core";
+import { QueryClient, notifyManager, replaceEqualDeep } from "@tanstack/query-core";
+//#region src/inject-mutation-state.ts
+function getResult(mutationCache, options) {
+	return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
+}
+/**
+* Injects a signal that gives you access to all mutations in the `MutationCache`. You can pass `filters`
+* ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation state.
+*
+* @param injectMutationStateFn - A function returning the `filters` to narrow down matched mutations, and an
+* optional `select` to transform the mutation state. Similar to `computed` from Angular, this function runs
+* in the reactive context, so signals read inside it re-narrow the matched mutations.
+* @param options - Additional configuration
+* @returns A `Signal` with an Array of whatever `select` returns for each matching mutation.
+*
+* @example
+* Get all variables of all running mutations:
+* ```angular-ts
+* @Component({
+*   selector: 'pending-posts',
+*   template: `{{ pendingVariables().length }} posts saving...`,
+* })
+* export class PendingPosts {
+*   readonly pendingVariables = injectMutationState(() => ({
+*     filters: { status: 'pending' },
+*     select: (mutation) => mutation.state.variables,
+*   }))
+* }
+* ```
+*
+* @example
+* Get all data for specific mutations via the `mutationKey`:
+* ```angular-ts
+* const mutationKey = ['posts']
+*
+* @Component({
+*   selector: 'posts',
+*   template: `
+*     <button (click)="createPost()">
+*       Create post ({{ savedPosts().length }} saved so far)
+*     </button>
+*   `,
+* })
+* export class Posts {
+*   // Some mutation that we want to get the state for
+*   readonly createPostMutation = injectMutation(() => ({
+*     mutationKey,
+*     mutationFn: createPosts,
+*   }))
+*
+*   readonly savedPosts = injectMutationState(() => ({
+*     // this mutation key needs to match the mutation key of the given mutation (see above)
+*     filters: { mutationKey, status: 'success' },
+*     select: (mutation) => mutation.state.data,
+*   }))
+*
+*   createPost() {
+*     this.createPostMutation.mutate(['New Post'])
+*   }
+* }
+* ```
+*/
+function injectMutationState(injectMutationStateFn = () => ({}), options) {
+	!options?.injector && assertInInjectionContext(injectMutationState);
+	const injector = options?.injector ?? inject(Injector);
+	const destroyRef = injector.get(DestroyRef);
+	const ngZone = injector.get(NgZone);
+	const mutationCache = injector.get(QueryClient).getMutationCache();
+	/**
+	* Computed signal that gets result from mutation cache based on passed options
+	* First element is the result, second element is the time when the result was set
+	*/
+	const resultFromOptionsSignal = computed(() => {
+		return [getResult(mutationCache, injectMutationStateFn()), performance.now()];
+	});
+	/**
+	* Signal that contains result set by subscriber
+	* First element is the result, second element is the time when the result was set
+	*/
+	const resultFromSubscriberSignal = signal(null);
+	/**
+	* Returns the last result by either subscriber or options
+	*/
+	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;
+}
+//#endregion
+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","names":[],"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\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\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 gives you access to all mutations in the `MutationCache`. You can pass `filters`\n * ({@link MutationFilters}) to narrow down your mutations, and `select` to transform the mutation state.\n *\n * @param injectMutationStateFn - A function returning the `filters` to narrow down matched mutations, and an\n * optional `select` to transform the mutation state. Similar to `computed` from Angular, this function runs\n * in the reactive context, so signals read inside it re-narrow the matched mutations.\n * @param options - Additional configuration\n * @returns A `Signal` with an Array of whatever `select` returns for each matching mutation.\n *\n * @example\n * Get all variables of all running mutations:\n * ```angular-ts\n * @Component({\n *   selector: 'pending-posts',\n *   template: `{{ pendingVariables().length }} posts saving...`,\n * })\n * export class PendingPosts {\n *   readonly pendingVariables = injectMutationState(() => ({\n *     filters: { status: 'pending' },\n *     select: (mutation) => mutation.state.variables,\n *   }))\n * }\n * ```\n *\n * @example\n * Get all data for specific mutations via the `mutationKey`:\n * ```angular-ts\n * const mutationKey = ['posts']\n *\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <button (click)=\"createPost()\">\n *       Create post ({{ savedPosts().length }} saved so far)\n *     </button>\n *   `,\n * })\n * export class Posts {\n *   // Some mutation that we want to get the state for\n *   readonly createPostMutation = injectMutation(() => ({\n *     mutationKey,\n *     mutationFn: createPosts,\n *   }))\n *\n *   readonly savedPosts = injectMutationState(() => ({\n *     // this mutation key needs to match the mutation key of the given mutation (see above)\n *     filters: { mutationKey, status: 'success' },\n *     select: (mutation) => mutation.state.data,\n *   }))\n *\n *   createPost() {\n *     this.createPostMutation.mutate(['New Post'])\n *   }\n * }\n * ```\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"],"mappings":";;;AA2BA,SAAS,UACP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SAAS,QAAQ,OAAO,QAAQ,IAAI,SAAS,KAC1D;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,oBACd,+BAAoE,CAAC,IACrE,SACwB;CACxB,CAAC,SAAS,YAAY,yBAAyB,mBAAmB;CAClE,MAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;CACrD,MAAM,aAAa,SAAS,IAAI,UAAU;CAC1C,MAAM,SAAS,SAAS,IAAI,MAAM;CAElC,MAAM,gBADc,SAAS,IAAI,WACD,CAAC,CAAC,iBAAiB;;;;;CAMnD,MAAM,0BAA0B,eAAe;EAC7C,OAAO,CACL,UAAU,eAAe,sBAAsB,CAAC,GAChD,YAAY,IAAI,CAClB;CACF,CAAC;;;;;CAMD,MAAM,6BAA6B,OACjC,IACF;;;;CAKA,MAAM,wBAAwB,eAAe;EAC3C,MAAM,gBAAgB,wBAAwB;EAC9C,MAAM,mBAAmB,2BAA2B;EACpD,OAAO,oBAAoB,iBAAiB,KAAK,cAAc,KAC3D,iBAAiB,KACjB,cAAc;CACpB,CAAC;CAED,MAAM,cAAc,OAAO,wBACzB,cAAc,UACZ,cAAc,iBAAiB;EAC7B,MAAM,CAAC,cAAc,sBAAsB;EAC3C,MAAM,aAAa,iBACjB,YACA,UAAU,eAAe,sBAAsB,CAAC,CAClD;EACA,IAAI,eAAe,YACjB,OAAO,UAAU;GACf,2BAA2B,IAAI,CAAC,YAAY,YAAY,IAAI,CAAC,CAAC;EAChE,CAAC;CAEL,CAAC,CACH,CACF;CAEA,WAAW,UAAU,WAAW;CAEhC,OAAO;AACT"}

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

@@ -1,13 +1,14 @@
-import { Injector } from '@angular/core';
-import { DefaultError } from '@tanstack/query-core';
-import { CreateMutationOptions, CreateMutationResult } from './types.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;
+import { CreateMutationOptions, CreateMutationResult } from "./types.mjs";
+import { Injector } from "@angular/core";
+import { DefaultError } from "@tanstack/query-core";
+//#region src/inject-mutation.d.ts
+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;
 }
 /**
  * Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects.
@@ -146,4 +147,7 @@ export interface InjectMutationOptions {
  * }
  * ```
  */
-export declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TOnMutateResult>;
+declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TOnMutateResult>;
+//#endregion
+export { InjectMutationOptions, injectMutation };
+//# sourceMappingURL=inject-mutation.d.mts.map

package/dist/inject-mutation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-mutation.d.mts","names":[],"sources":["../src/inject-mutation.ts"],"mappings":";;;;UA2BiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4IG,eACd,iBACA,SAAS,cACT,mBACA,2BAEA,wBAAwB,sBACtB,OACA,QACA,YACA,kBAEF,UAAU,wBACT,qBAAqB,OAAO,QAAQ,YAAY"}

package/dist/inject-mutation.mjs

@@ -0,0 +1,226 @@
+import { signalProxy } from "./signal-proxy.mjs";
+import { PENDING_TASKS } from "./pending-tasks-compat.mjs";
+import { Injector, NgZone, assertInInjectionContext, computed, effect, inject, signal, untracked } from "@angular/core";
+import { MutationObserver, QueryClient, noop, notifyManager, shouldThrowError } from "@tanstack/query-core";
+//#region src/inject-mutation.ts
+/**
+* Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects.
+* `injectMutation` is the function for that. Unlike queries, mutations are not run automatically.
+*
+* @remarks `mutate`/`mutateAsync` also accept per-call `onSuccess`/`onError`/`onSettled` callbacks as a
+* second argument, useful for triggering call-site side effects (e.g. navigation) without coupling them to
+* the shared mutation definition. Callbacks defined in `injectMutationFn` fire for every mutation; per-call
+* callbacks fire only for the latest call you've made — `mutateAsync` gives you a promise per call instead,
+* so you can await `Promise.all`/`Promise.allSettled` over several calls and see each one's outcome.
+* @see {@link mutationOptions} to share these options across multiple `injectMutation` call sites, or to look
+* the mutation up elsewhere via its `mutationKey` (e.g. with `injectMutationState`).
+* @param injectMutationFn - A function that returns mutation options. Similar to `computed` from Angular,
+* this function runs in the reactive context, so signals read inside it drive the mutation's options.
+* @param options - Additional configuration
+* @returns The mutation result. Value fields are exposed as a `Signal` — read `data`/`error` by calling them
+* (e.g. `mutation.data()`) — while function fields (`mutate`, `mutateAsync`, `reset`) are called directly,
+* unchanged. `isSuccess`/`isError`/`isPending`/`isIdle` are type-guard methods you can call to narrow whether
+* `data` is defined.
+*
+* @example
+* ```angular-ts
+* @Component({
+*   selector: 'todos',
+*   template: `
+*     @if (addMutation.isPending()) {
+*       <span>Adding todo...</span>
+*     } @else if (addMutation.isError()) {
+*       <div>An error occurred: {{ addMutation.error()?.message }}</div>
+*     }
+*     <button (click)="addMutation.mutate('Item')">Add</button>
+*   `,
+* })
+* export class Todos {
+*   readonly #queryClient = inject(QueryClient)
+*
+*   readonly addMutation = injectMutation(() => ({
+*     mutationFn: addTodo,
+*     onSuccess: () => this.#queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   }))
+* }
+* ```
+*
+* @example
+* Optimistic update via `onMutate`, rolling back on `onError`:
+* ```angular-ts
+* @Component({
+*   selector: 'todos',
+*   template: `<button (click)="addMutation.mutate('Item')">Add</button>`,
+* })
+* export class Todos {
+*   readonly #queryClient = inject(QueryClient)
+*
+*   readonly addMutation = injectMutation(() => ({
+*     mutationFn: addTodo,
+*     onMutate: async (newTodo) => {
+*       await this.#queryClient.cancelQueries({ queryKey: ['todos'] })
+*       const previousTodos = this.#queryClient.getQueryData<Array<string>>(['todos'])
+*
+*       this.#queryClient.setQueryData<Array<string>>(['todos'], (old) => [
+*         ...(old ?? []),
+*         newTodo,
+*       ])
+*
+*       // Passed to `onError` as `onMutateResult` if the mutation fails.
+*       return { previousTodos }
+*     },
+*     onError: (_err, _newTodo, onMutateResult) => {
+*       this.#queryClient.setQueryData(['todos'], onMutateResult?.previousTodos)
+*     },
+*     onSettled: () => {
+*       this.#queryClient.invalidateQueries({ queryKey: ['todos'] })
+*     },
+*   }))
+* }
+* ```
+*
+* @example
+* Callbacks passed per call to `mutate` only fire for the last call — `mutateAsync` gives you a promise per
+* call instead, so you can wait for all of them when they succeed:
+* ```angular-ts
+* @Component({
+*   selector: 'todos',
+*   template: `
+*     <button (click)="handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])">Add all</button>
+*   `,
+* })
+* export class Todos {
+*   readonly #queryClient = inject(QueryClient)
+*
+*   readonly addMutation = injectMutation(() => ({
+*     mutationFn: addTodo,
+*     onSuccess: () => this.#queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   }))
+*
+*   async handleAddAll(todos: Array<string>) {
+*     try {
+*       await Promise.all(todos.map((todo) => this.addMutation.mutateAsync(todo)))
+*     } catch (error) {
+*       console.error('Failed to add todos:', error)
+*     }
+*   }
+* }
+* ```
+*
+* @example
+* If some of the mutations above can fail independently of the others, and you want to know which ones did —
+* rather than losing that information the moment the first one rejects — swap `Promise.all` for
+* `Promise.allSettled`:
+* ```angular-ts
+* @Component({
+*   selector: 'todos',
+*   template: `
+*     <button (click)="handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])">Add all</button>
+*   `,
+* })
+* export class Todos {
+*   readonly #queryClient = inject(QueryClient)
+*
+*   readonly addMutation = injectMutation(() => ({
+*     mutationFn: addTodo,
+*     onSuccess: () => this.#queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   }))
+*
+*   async handleAddAll(todos: Array<string>) {
+*     const addResults = await Promise.allSettled(
+*       todos.map((todo) => this.addMutation.mutateAsync(todo)),
+*     )
+*
+*     addResults.forEach((addResult, index) => {
+*       if (addResult.status === 'rejected') {
+*         console.error(`Failed to add "${todos[index]}":`, addResult.reason)
+*       }
+*     })
+*   }
+* }
+* ```
+*/
+function injectMutation(injectMutationFn, options) {
+	!options?.injector && assertInInjectionContext(injectMutation);
+	const injector = options?.injector ?? inject(Injector);
+	const ngZone = injector.get(NgZone);
+	const pendingTasks = injector.get(PENDING_TASKS);
+	const queryClient = injector.get(QueryClient);
+	/**
+	* computed() is used so signals can be inserted into the options
+	* making it reactive. Wrapping options in a function ensures embedded expressions
+	* are preserved and can keep being applied after signal changes
+	*/
+	const optionsSignal = computed(injectMutationFn);
+	const observerSignal = (() => {
+		let instance = null;
+		return computed(() => {
+			return instance ||= new MutationObserver(queryClient, optionsSignal());
+		});
+	})();
+	const mutateFnSignal = computed(() => {
+		const observer = observerSignal();
+		return (...args) => {
+			observer.mutate(args[0], args[1]).catch(noop);
+		};
+	});
+	/**
+	* Computed signal that gets result from mutation cache based on passed options
+	*/
+	const resultFromInitialOptionsSignal = computed(() => {
+		return observerSignal().getCurrentResult();
+	});
+	/**
+	* Signal that contains result set by subscriber
+	*/
+	const resultFromSubscriberSignal = signal(null);
+	effect(() => {
+		const observer = observerSignal();
+		const observerOptions = optionsSignal();
+		untracked(() => {
+			observer.setOptions(observerOptions);
+		});
+	}, { injector });
+	effect((onCleanup) => {
+		const observer = observerSignal();
+		let pendingTaskRef = null;
+		untracked(() => {
+			const unsubscribe = ngZone.runOutsideAngular(() => observer.subscribe(notifyManager.batchCalls((state) => {
+				ngZone.run(() => {
+					if (state.isPending && !pendingTaskRef) pendingTaskRef = pendingTasks.add();
+					if (!state.isPending && pendingTaskRef) {
+						pendingTaskRef();
+						pendingTaskRef = null;
+					}
+					if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+						ngZone.onError.emit(state.error);
+						throw state.error;
+					}
+					resultFromSubscriberSignal.set(state);
+				});
+			})));
+			onCleanup(() => {
+				if (pendingTaskRef) {
+					pendingTaskRef();
+					pendingTaskRef = null;
+				}
+				unsubscribe();
+			});
+		});
+	}, { injector });
+	const resultSignal = computed(() => {
+		const resultFromSubscriber = resultFromSubscriberSignal();
+		const resultFromInitialOptions = resultFromInitialOptionsSignal();
+		const result = resultFromSubscriber ?? resultFromInitialOptions;
+		return {
+			...result,
+			mutate: mutateFnSignal(),
+			mutateAsync: result.mutate
+		};
+	});
+	return signalProxy(resultSignal);
+}
+//#endregion
+export { injectMutation };
+
+//# sourceMappingURL=inject-mutation.mjs.map