@tanstack/angular-query-experimental 5.83.0 → 5.83.1

package/dist/inject-mutation.mjs

@@ -0,0 +1,79 @@
+import { assertInInjectionContext, inject, Injector, DestroyRef, NgZone, computed, signal, effect, untracked } from "@angular/core";
+import { QueryClient, MutationObserver, noop, notifyManager, shouldThrowError } from "@tanstack/query-core";
+import { signalProxy } from "./signal-proxy.mjs";
+function injectMutation(injectMutationFn, options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectMutation);
+  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 optionsSignal = computed(injectMutationFn);
+  const observerSignal = (() => {
+    let instance = null;
+    return computed(() => {
+      return instance || (instance = new MutationObserver(queryClient, optionsSignal()));
+    });
+  })();
+  const mutateFnSignal = computed(() => {
+    const observer = observerSignal();
+    return (variables, mutateOptions) => {
+      observer.mutate(variables, mutateOptions).catch(noop);
+    };
+  });
+  const resultFromInitialOptionsSignal = computed(() => {
+    const observer = observerSignal();
+    return observer.getCurrentResult();
+  });
+  const resultFromSubscriberSignal = signal(null);
+  effect(
+    () => {
+      const observer = observerSignal();
+      const observerOptions = optionsSignal();
+      untracked(() => {
+        observer.setOptions(observerOptions);
+      });
+    },
+    {
+      injector
+    }
+  );
+  effect(
+    () => {
+      const observer = observerSignal();
+      untracked(() => {
+        const unsubscribe = ngZone.runOutsideAngular(
+          () => observer.subscribe(
+            notifyManager.batchCalls((state) => {
+              ngZone.run(() => {
+                if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+                  ngZone.onError.emit(state.error);
+                  throw state.error;
+                }
+                resultFromSubscriberSignal.set(state);
+              });
+            })
+          )
+        );
+        destroyRef.onDestroy(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);
+}
+export {
+  injectMutation
+};
+//# sourceMappingURL=inject-mutation.mjs.map

package/dist/inject-mutation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-mutation.mjs","sources":["../src/inject-mutation.ts"],"sourcesContent":["import {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  signal,\n  untracked,\n} from '@angular/core'\nimport {\n  MutationObserver,\n  QueryClient,\n  noop,\n  notifyManager,\n  shouldThrowError,\n} from '@tanstack/query-core'\nimport { signalProxy } from './signal-proxy'\nimport type { DefaultError, MutationObserverResult } from '@tanstack/query-core'\nimport type { CreateMutateFunction, CreateMutationResult } from './types'\nimport type { CreateMutationOptions } from './mutation-options'\n\nexport interface InjectMutationOptions {\n  /**\n   * The `Injector` in which to create the mutation.\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 mutation: an imperative function that can be invoked which typically performs server side effects.\n *\n * Unlike queries, mutations are not run automatically.\n * @param injectMutationFn - A function that returns mutation options.\n * @param options - Additional configuration\n * @returns The mutation.\n * @public\n */\nexport function injectMutation<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n>(\n  injectMutationFn: () => CreateMutationOptions<\n    TData,\n    TError,\n    TVariables,\n    TContext\n  >,\n  options?: InjectMutationOptions,\n): CreateMutationResult<TData, TError, TVariables, TContext> {\n  !options?.injector && assertInInjectionContext(injectMutation)\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  /**\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 optionsSignal = computed(injectMutationFn)\n\n  const observerSignal = (() => {\n    let instance: MutationObserver<TData, TError, TVariables, TContext> | null =\n      null\n\n    return computed(() => {\n      return (instance ||= new MutationObserver(queryClient, optionsSignal()))\n    })\n  })()\n\n  const mutateFnSignal = computed<\n    CreateMutateFunction<TData, TError, TVariables, TContext>\n  >(() => {\n    const observer = observerSignal()\n    return (variables, mutateOptions) => {\n      observer.mutate(variables, mutateOptions).catch(noop)\n    }\n  })\n\n  /**\n   * Computed signal that gets result from mutation cache based on passed options\n   */\n  const resultFromInitialOptionsSignal = computed(() => {\n    const observer = observerSignal()\n    return observer.getCurrentResult()\n  })\n\n  /**\n   * Signal that contains result set by subscriber\n   */\n  const resultFromSubscriberSignal = signal<MutationObserverResult<\n    TData,\n    TError,\n    TVariables,\n    TContext\n  > | null>(null)\n\n  effect(\n    () => {\n      const observer = observerSignal()\n      const observerOptions = optionsSignal()\n\n      untracked(() => {\n        observer.setOptions(observerOptions)\n      })\n    },\n    {\n      injector,\n    },\n  )\n\n  effect(\n    () => {\n      // observer.trackResult is not used as this optimization is not needed for Angular\n      const observer = observerSignal()\n\n      untracked(() => {\n        const unsubscribe = ngZone.runOutsideAngular(() =>\n          observer.subscribe(\n            notifyManager.batchCalls((state) => {\n              ngZone.run(() => {\n                if (\n                  state.isError &&\n                  shouldThrowError(observer.options.throwOnError, [state.error])\n                ) {\n                  ngZone.onError.emit(state.error)\n                  throw state.error\n                }\n\n                resultFromSubscriberSignal.set(state)\n              })\n            }),\n          ),\n        )\n        destroyRef.onDestroy(unsubscribe)\n      })\n    },\n    {\n      injector,\n    },\n  )\n\n  const resultSignal = computed(() => {\n    const resultFromSubscriber = resultFromSubscriberSignal()\n    const resultFromInitialOptions = resultFromInitialOptionsSignal()\n\n    const result = resultFromSubscriber ?? resultFromInitialOptions\n\n    return {\n      ...result,\n      mutate: mutateFnSignal(),\n      mutateAsync: result.mutate,\n    }\n  })\n\n  return signalProxy(resultSignal) as CreateMutationResult<\n    TData,\n    TError,\n    TVariables,\n    TContext\n  >\n}\n"],"names":[],"mappings":";;;AAyCgB,SAAA,eAMd,kBAMA,SAC2D;AAC1D,IAAA,mCAAS,aAAY,yBAAyB,cAAc;AAC7D,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;AAOtC,QAAA,gBAAgB,SAAS,gBAAgB;AAE/C,QAAM,kBAAkB,MAAM;AAC5B,QAAI,WACF;AAEF,WAAO,SAAS,MAAM;AACpB,aAAQ,wBAAa,IAAI,iBAAiB,aAAa,eAAe;AAAA,IAAA,CACvE;AAAA,EAAA,GACA;AAEG,QAAA,iBAAiB,SAErB,MAAM;AACN,UAAM,WAAW,eAAe;AACzB,WAAA,CAAC,WAAW,kBAAkB;AACnC,eAAS,OAAO,WAAW,aAAa,EAAE,MAAM,IAAI;AAAA,IACtD;AAAA,EAAA,CACD;AAKK,QAAA,iCAAiC,SAAS,MAAM;AACpD,UAAM,WAAW,eAAe;AAChC,WAAO,SAAS,iBAAiB;AAAA,EAAA,CAClC;AAKK,QAAA,6BAA6B,OAKzB,IAAI;AAEd;AAAA,IACE,MAAM;AACJ,YAAM,WAAW,eAAe;AAChC,YAAM,kBAAkB,cAAc;AAEtC,gBAAU,MAAM;AACd,iBAAS,WAAW,eAAe;AAAA,MAAA,CACpC;AAAA,IACH;AAAA,IACA;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AAEA;AAAA,IACE,MAAM;AAEJ,YAAM,WAAW,eAAe;AAEhC,gBAAU,MAAM;AACd,cAAM,cAAc,OAAO;AAAA,UAAkB,MAC3C,SAAS;AAAA,YACP,cAAc,WAAW,CAAC,UAAU;AAClC,qBAAO,IAAI,MAAM;AAEb,oBAAA,MAAM,WACN,iBAAiB,SAAS,QAAQ,cAAc,CAAC,MAAM,KAAK,CAAC,GAC7D;AACO,yBAAA,QAAQ,KAAK,MAAM,KAAK;AAC/B,wBAAM,MAAM;AAAA,gBAAA;AAGd,2CAA2B,IAAI,KAAK;AAAA,cAAA,CACrC;AAAA,YACF,CAAA;AAAA,UAAA;AAAA,QAEL;AACA,mBAAW,UAAU,WAAW;AAAA,MAAA,CACjC;AAAA,IACH;AAAA,IACA;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AAEM,QAAA,eAAe,SAAS,MAAM;AAClC,UAAM,uBAAuB,2BAA2B;AACxD,UAAM,2BAA2B,+BAA+B;AAEhE,UAAM,SAAS,wBAAwB;AAEhC,WAAA;AAAA,MACL,GAAG;AAAA,MACH,QAAQ,eAAe;AAAA,MACvB,aAAa,OAAO;AAAA,IACtB;AAAA,EAAA,CACD;AAED,SAAO,YAAY,YAAY;AAMjC;"}

package/dist/inject-queries.d.ts

@@ -0,0 +1,76 @@
+import { Injector, Signal } from '@angular/core';
+import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryFunction, QueryKey, QueryObserverOptions, QueryObserverResult, ThrowOnError } from '@tanstack/query-core';
+type QueryObserverOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'placeholderData'> & {
+    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
+type MAXIMUM_DEPTH = 20;
+type SkipTokenForUseQueries = symbol;
+type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? QueryObserverOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverOptionsForCreateQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+    select: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? QueryObserverOptionsForCreateQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : QueryObserverOptionsForCreateQueries;
+type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? QueryObserverResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? QueryObserverResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? QueryObserverResult<TData, TError> : T extends [any, infer TError, infer TData] ? QueryObserverResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? QueryObserverResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    select: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : QueryObserverResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ * @public
+ */
+export type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
+    ...Tail
+], [
+    ...TResult,
+    GetOptions<Head>
+], [
+    ...TDepth,
+    1
+]> : ReadonlyArray<unknown> extends T ? T : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
+/**
+ * QueriesResults reducer recursively maps type param to results
+ * @public
+ */
+export type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
+    ...Tail
+], [
+    ...TResult,
+    GetResults<Head>
+], [
+    ...TDepth,
+    1
+]> : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>> ? Array<QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError>> : Array<QueryObserverResult>;
+/**
+ * @param root0
+ * @param root0.queries
+ * @param root0.combine
+ * @param injector
+ * @param injector
+ * @public
+ */
+export declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
+    queries: Signal<[...QueriesOptions<T>]>;
+    combine?: (result: QueriesResults<T>) => TCombinedResult;
+}, injector?: Injector): Signal<TCombinedResult>;
+export {};

package/dist/inject-queries.mjs

@@ -0,0 +1,49 @@
+import { QueryClient, QueriesObserver, notifyManager } from "@tanstack/query-core";
+import { assertInInjectionContext, runInInjectionContext, inject, Injector, DestroyRef, NgZone, computed, effect, signal } from "@angular/core";
+import { injectIsRestoring } from "./inject-is-restoring.mjs";
+function injectQueries({
+  queries,
+  ...options
+}, injector) {
+  !injector && assertInInjectionContext(injectQueries);
+  return runInInjectionContext(injector ?? inject(Injector), () => {
+    const destroyRef = inject(DestroyRef);
+    const ngZone = inject(NgZone);
+    const queryClient = inject(QueryClient);
+    const isRestoring = injectIsRestoring();
+    const defaultedQueries = computed(() => {
+      return queries().map((opts) => {
+        const defaultedOptions = queryClient.defaultQueryOptions(opts);
+        defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+        return defaultedOptions;
+      });
+    });
+    const observer = new QueriesObserver(
+      queryClient,
+      defaultedQueries(),
+      options
+    );
+    effect(() => {
+      observer.setQueries(
+        defaultedQueries(),
+        options
+      );
+    });
+    const [, getCombinedResult] = observer.getOptimisticResult(
+      defaultedQueries(),
+      options.combine
+    );
+    const result = signal(getCombinedResult());
+    effect(() => {
+      const unsubscribe = isRestoring() ? () => void 0 : ngZone.runOutsideAngular(
+        () => observer.subscribe(notifyManager.batchCalls(result.set))
+      );
+      destroyRef.onDestroy(unsubscribe);
+    });
+    return result;
+  });
+}
+export {
+  injectQueries
+};
+//# sourceMappingURL=inject-queries.mjs.map

package/dist/inject-queries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-queries.mjs","sources":["../src/inject-queries.ts"],"sourcesContent":["import {\n  QueriesObserver,\n  QueryClient,\n  notifyManager,\n} from '@tanstack/query-core'\nimport {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  runInInjectionContext,\n  signal,\n} from '@angular/core'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport type { Signal } from '@angular/core'\nimport type {\n  DefaultError,\n  OmitKeyof,\n  QueriesObserverOptions,\n  QueriesPlaceholderDataFunction,\n  QueryFunction,\n  QueryKey,\n  QueryObserverOptions,\n  QueryObserverResult,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function does not have a parameter\ntype QueryObserverOptionsForCreateQueries<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n  'placeholderData'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetOptions<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? QueryObserverOptionsForCreateQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? QueryObserverOptionsForCreateQueries<\n                    TQueryFnData,\n                    unknown extends TError ? DefaultError : TError,\n                    unknown extends TData ? TQueryFnData : TData,\n                    TQueryKey\n                  >\n                : // Fallback\n                  QueryObserverOptionsForCreateQueries\n\ntype GetResults<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? QueryObserverResult<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? QueryObserverResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? QueryObserverResult<TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? QueryObserverResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? QueryObserverResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? QueryObserverResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? QueryObserverResult<\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : // Fallback\n                  QueryObserverResult\n\n/**\n * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n * @public\n */\nexport type QueriesOptions<\n  T extends Array<any>,\n  TResult extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<QueryObserverOptionsForCreateQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResult, GetOptions<Head>]\n      : T extends [infer Head, ...infer Tail]\n        ? QueriesOptions<\n            [...Tail],\n            [...TResult, GetOptions<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                QueryObserverOptionsForCreateQueries<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                QueryObserverOptionsForCreateQueries<\n                  TQueryFnData,\n                  TError,\n                  TData,\n                  TQueryKey\n                >\n              >\n            : // Fallback\n              Array<QueryObserverOptionsForCreateQueries>\n\n/**\n * QueriesResults reducer recursively maps type param to results\n * @public\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResult extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<QueryObserverResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResult, GetResults<Head>]\n      : T extends [infer Head, ...infer Tail]\n        ? QueriesResults<\n            [...Tail],\n            [...TResult, GetResults<Head>],\n            [...TDepth, 1]\n          >\n        : T extends Array<\n              QueryObserverOptionsForCreateQueries<\n                infer TQueryFnData,\n                infer TError,\n                infer TData,\n                any\n              >\n            >\n          ? // Dynamic-size (homogenous) CreateQueryOptions array: map directly to array of results\n            Array<\n              QueryObserverResult<\n                unknown extends TData ? TQueryFnData : TData,\n                unknown extends TError ? DefaultError : TError\n              >\n            >\n          : // Fallback\n            Array<QueryObserverResult>\n\n/**\n * @param root0\n * @param root0.queries\n * @param root0.combine\n * @param injector\n * @param injector\n * @public\n */\nexport function injectQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  {\n    queries,\n    ...options\n  }: {\n    queries: Signal<[...QueriesOptions<T>]>\n    combine?: (result: QueriesResults<T>) => TCombinedResult\n  },\n  injector?: Injector,\n): Signal<TCombinedResult> {\n  !injector && assertInInjectionContext(injectQueries)\n  return runInInjectionContext(injector ?? inject(Injector), () => {\n    const destroyRef = inject(DestroyRef)\n    const ngZone = inject(NgZone)\n    const queryClient = inject(QueryClient)\n    const isRestoring = injectIsRestoring()\n\n    const defaultedQueries = computed(() => {\n      return queries().map((opts) => {\n        const defaultedOptions = queryClient.defaultQueryOptions(opts)\n        // Make sure the results are already in fetching state before subscribing or updating options\n        defaultedOptions._optimisticResults = isRestoring()\n          ? 'isRestoring'\n          : 'optimistic'\n\n        return defaultedOptions as QueryObserverOptions\n      })\n    })\n\n    const observer = new QueriesObserver<TCombinedResult>(\n      queryClient,\n      defaultedQueries(),\n      options as QueriesObserverOptions<TCombinedResult>,\n    )\n\n    // Do not notify on updates because of changes in the options because\n    // these changes should already be reflected in the optimistic result.\n    effect(() => {\n      observer.setQueries(\n        defaultedQueries(),\n        options as QueriesObserverOptions<TCombinedResult>,\n      )\n    })\n\n    const [, getCombinedResult] = observer.getOptimisticResult(\n      defaultedQueries(),\n      (options as QueriesObserverOptions<TCombinedResult>).combine,\n    )\n\n    const result = signal(getCombinedResult() as any)\n\n    effect(() => {\n      const unsubscribe = isRestoring()\n        ? () => undefined\n        : ngZone.runOutsideAngular(() =>\n            observer.subscribe(notifyManager.batchCalls(result.set)),\n          )\n      destroyRef.onDestroy(unsubscribe)\n    })\n\n    return result\n  })\n}\n"],"names":[],"mappings":";;;AA6MO,SAAS,cAId;AAAA,EACE;AAAA,EACA,GAAG;AACL,GAIA,UACyB;AACxB,GAAA,YAAY,yBAAyB,aAAa;AACnD,SAAO,sBAAsB,YAAY,OAAO,QAAQ,GAAG,MAAM;AACzD,UAAA,aAAa,OAAO,UAAU;AAC9B,UAAA,SAAS,OAAO,MAAM;AACtB,UAAA,cAAc,OAAO,WAAW;AACtC,UAAM,cAAc,kBAAkB;AAEhC,UAAA,mBAAmB,SAAS,MAAM;AACtC,aAAO,QAAQ,EAAE,IAAI,CAAC,SAAS;AACvB,cAAA,mBAAmB,YAAY,oBAAoB,IAAI;AAE5C,yBAAA,qBAAqB,YAAY,IAC9C,gBACA;AAEG,eAAA;AAAA,MAAA,CACR;AAAA,IAAA,CACF;AAED,UAAM,WAAW,IAAI;AAAA,MACnB;AAAA,MACA,iBAAiB;AAAA,MACjB;AAAA,IACF;AAIA,WAAO,MAAM;AACF,eAAA;AAAA,QACP,iBAAiB;AAAA,QACjB;AAAA,MACF;AAAA,IAAA,CACD;AAED,UAAM,CAAG,EAAA,iBAAiB,IAAI,SAAS;AAAA,MACrC,iBAAiB;AAAA,MAChB,QAAoD;AAAA,IACvD;AAEM,UAAA,SAAS,OAAO,mBAA0B;AAEhD,WAAO,MAAM;AACX,YAAM,cAAc,YAAA,IAChB,MAAM,SACN,OAAO;AAAA,QAAkB,MACvB,SAAS,UAAU,cAAc,WAAW,OAAO,GAAG,CAAC;AAAA,MACzD;AACJ,iBAAW,UAAU,WAAW;AAAA,IAAA,CACjC;AAEM,WAAA;AAAA,EAAA,CACR;AACH;"}

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

@@ -0,0 +1,19 @@
+import { Injector, InjectOptions } from '@angular/core';
+import { QueryClient } from '@tanstack/query-core';
+/**
+ * Injects a `QueryClient` instance and allows passing a custom injector.
+ * @param injectOptions - Type of the options argument to inject and optionally a custom injector.
+ * @returns The `QueryClient` instance.
+ * @public
+ * @deprecated Use `inject(QueryClient)` instead.
+ * If you need to get a `QueryClient` from a custom injector, use `injector.get(QueryClient)`.
+ *
+ *
+ * **Example**
+ * ```ts
+ * const queryClient = injectQueryClient();
+ * ```
+ */
+export declare function injectQueryClient(injectOptions?: InjectOptions & {
+    injector?: Injector;
+}): QueryClient;

package/dist/inject-query-client.mjs

@@ -0,0 +1,9 @@
+import { inject, Injector } from "@angular/core";
+import { QueryClient } from "@tanstack/query-core";
+function injectQueryClient(injectOptions = {}) {
+  return (injectOptions.injector ?? inject(Injector)).get(QueryClient);
+}
+export {
+  injectQueryClient
+};
+//# sourceMappingURL=inject-query-client.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-query-client.mjs","sources":["../src/inject-query-client.ts"],"sourcesContent":["import { Injector, inject } from '@angular/core'\nimport { QueryClient } from '@tanstack/query-core'\nimport type { InjectOptions } from '@angular/core'\n\n/**\n * Injects a `QueryClient` instance and allows passing a custom injector.\n * @param injectOptions - Type of the options argument to inject and optionally a custom injector.\n * @returns The `QueryClient` instance.\n * @public\n * @deprecated Use `inject(QueryClient)` instead.\n * If you need to get a `QueryClient` from a custom injector, use `injector.get(QueryClient)`.\n *\n *\n * **Example**\n * ```ts\n * const queryClient = injectQueryClient();\n * ```\n */\nexport function injectQueryClient(\n  injectOptions: InjectOptions & { injector?: Injector } = {},\n) {\n  return (injectOptions.injector ?? inject(Injector)).get(QueryClient)\n}\n"],"names":[],"mappings":";;AAkBgB,SAAA,kBACd,gBAAyD,IACzD;AACA,UAAQ,cAAc,YAAY,OAAO,QAAQ,GAAG,IAAI,WAAW;AACrE;"}

package/dist/inject-query.d.ts

@@ -0,0 +1,126 @@
+import { Injector } from '@angular/core';
+import { DefaultError, QueryKey } from '@tanstack/query-core';
+import { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types.js';
+import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-options.js';
+export interface InjectQueryOptions {
+    /**
+     * The `Injector` in which to create the query.
+     *
+     * If this is not provided, the current injection context will be used instead (via `inject`).
+     */
+    injector?: Injector;
+}
+/**
+ * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ *
+ * **Basic example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   query = injectQuery(() => ({
+ *     queryKey: ['repoData'],
+ *     queryFn: () =>
+ *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ *   }))
+ * }
+ * ```
+ *
+ * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
+ * In the example below, the query will be automatically enabled and executed when the filter signal changes
+ * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
+ *
+ * **Reactive example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   filter = signal('')
+ *
+ *   todosQuery = injectQuery(() => ({
+ *     queryKey: ['todos', this.filter()],
+ *     queryFn: () => fetchTodos(this.filter()),
+ *     // Signals can be combined with expressions
+ *     enabled: !!this.filter(),
+ *   }))
+ * }
+ * ```
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
+ * @returns The query result.
+ * @public
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ */
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): DefinedCreateQueryResult<TData, TError>;
+/**
+ * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ *
+ * **Basic example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   query = injectQuery(() => ({
+ *     queryKey: ['repoData'],
+ *     queryFn: () =>
+ *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ *   }))
+ * }
+ * ```
+ *
+ * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
+ * In the example below, the query will be automatically enabled and executed when the filter signal changes
+ * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
+ *
+ * **Reactive example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   filter = signal('')
+ *
+ *   todosQuery = injectQuery(() => ({
+ *     queryKey: ['todos', this.filter()],
+ *     queryFn: () => fetchTodos(this.filter()),
+ *     // Signals can be combined with expressions
+ *     enabled: !!this.filter(),
+ *   }))
+ * }
+ * ```
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
+ * @returns The query result.
+ * @public
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ */
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
+/**
+ * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
+ *
+ * **Basic example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   query = injectQuery(() => ({
+ *     queryKey: ['repoData'],
+ *     queryFn: () =>
+ *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
+ *   }))
+ * }
+ * ```
+ *
+ * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
+ * In the example below, the query will be automatically enabled and executed when the filter signal changes
+ * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
+ *
+ * **Reactive example**
+ * ```ts
+ * class ServiceOrComponent {
+ *   filter = signal('')
+ *
+ *   todosQuery = injectQuery(() => ({
+ *     queryKey: ['todos', this.filter()],
+ *     queryFn: () => fetchTodos(this.filter()),
+ *     // Signals can be combined with expressions
+ *     enabled: !!this.filter(),
+ *   }))
+ * }
+ * ```
+ * @param injectQueryFn - A function that returns query options.
+ * @param options - Additional configuration
+ * @returns The query result.
+ * @public
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
+ */
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;

package/dist/inject-query.mjs

@@ -0,0 +1,14 @@
+import { QueryObserver } from "@tanstack/query-core";
+import { assertInInjectionContext, runInInjectionContext, inject, Injector } from "@angular/core";
+import { createBaseQuery } from "./create-base-query.mjs";
+function injectQuery(injectQueryFn, options) {
+  !(options == null ? void 0 : options.injector) && assertInInjectionContext(injectQuery);
+  return runInInjectionContext(
+    (options == null ? void 0 : options.injector) ?? inject(Injector),
+    () => createBaseQuery(injectQueryFn, QueryObserver)
+  );
+}
+export {
+  injectQuery
+};
+//# sourceMappingURL=inject-query.mjs.map

package/dist/inject-query.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-query.mjs","sources":["../src/inject-query.ts"],"sourcesContent":["import { QueryObserver } 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 { DefaultError, QueryKey } from '@tanstack/query-core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type {\n  DefinedInitialDataOptions,\n  UndefinedInitialDataOptions,\n} from './query-options'\n\nexport interface InjectQueryOptions {\n  /**\n   * The `Injector` in which to create the 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 a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => DefinedInitialDataOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): DefinedCreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => UndefinedInitialDataOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): CreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  injectQueryFn: () => CreateQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey\n  >,\n  options?: InjectQueryOptions,\n): CreateQueryResult<TData, TError>\n\n/**\n * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.\n *\n * **Basic example**\n * ```ts\n * class ServiceOrComponent {\n *   query = injectQuery(() => ({\n *     queryKey: ['repoData'],\n *     queryFn: () =>\n *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),\n *   }))\n * }\n * ```\n *\n * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.\n * In the example below, the query will be automatically enabled and executed when the filter signal changes\n * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.\n *\n * **Reactive example**\n * ```ts\n * class ServiceOrComponent {\n *   filter = signal('')\n *\n *   todosQuery = injectQuery(() => ({\n *     queryKey: ['todos', this.filter()],\n *     queryFn: () => fetchTodos(this.filter()),\n *     // Signals can be combined with expressions\n *     enabled: !!this.filter(),\n *   }))\n * }\n * ```\n * @param injectQueryFn - A function that returns query options.\n * @param options - Additional configuration\n * @returns The query result.\n * @public\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n */\nexport function injectQuery(\n  injectQueryFn: () => CreateQueryOptions,\n  options?: InjectQueryOptions,\n) {\n  !options?.injector && assertInInjectionContext(injectQuery)\n  return runInInjectionContext(options?.injector ?? inject(Injector), () =>\n    createBaseQuery(injectQueryFn, QueryObserver),\n  ) as unknown as CreateQueryResult\n}\n"],"names":[],"mappings":";;;AA6NgB,SAAA,YACd,eACA,SACA;AACC,IAAA,mCAAS,aAAY,yBAAyB,WAAW;AACnD,SAAA;AAAA,KAAsB,mCAAS,aAAY,OAAO,QAAQ;AAAA,IAAG,MAClE,gBAAgB,eAAe,aAAa;AAAA,EAC9C;AACF;"}

package/dist/mutation-options.d.ts

@@ -0,0 +1,38 @@
+import { DefaultError, MutationObserverOptions, OmitKeyof } from '@tanstack/query-core';
+/**
+ * Allows to share and re-use mutation options in a type-safe way.
+ *
+ * **Example**
+ *
+ * ```ts
+ * export class QueriesService {
+ *   private http = inject(HttpClient);
+ *
+ *   updatePost(id: number) {
+ *     return mutationOptions({
+ *       mutationFn: (post: Post) => Promise.resolve(post),
+ *       mutationKey: ["updatePost", id],
+ *       onSuccess: (newPost) => {
+ *         //           ^? newPost: Post
+ *         this.queryClient.setQueryData(["posts", id], newPost);
+ *       },
+ *     });
+ *   }
+ * }
+ *
+ * queries = inject(QueriesService)
+ * idSignal = new Signal(0);
+ * mutation = injectMutation(() => this.queries.updatePost(this.idSignal()))
+ *
+ * mutation.mutate({ title: 'New Title' })
+ * ```
+ * @param options - The mutation options.
+ * @returns Mutation options.
+ * @public
+ */
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: MutationObserverOptions<TData, TError, TVariables, TContext>): CreateMutationOptions<TData, TError, TVariables, TContext>;
+/**
+ * @public
+ */
+export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
+}

package/dist/mutation-options.mjs

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

package/dist/mutation-options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-options.mjs","sources":["../src/mutation-options.ts"],"sourcesContent":["import type {\n  DefaultError,\n  MutationObserverOptions,\n  OmitKeyof,\n} from '@tanstack/query-core'\n\n/**\n * Allows to share and re-use mutation options in a type-safe way.\n *\n * **Example**\n *\n * ```ts\n * export class QueriesService {\n *   private http = inject(HttpClient);\n *\n *   updatePost(id: number) {\n *     return mutationOptions({\n *       mutationFn: (post: Post) => Promise.resolve(post),\n *       mutationKey: [\"updatePost\", id],\n *       onSuccess: (newPost) => {\n *         //           ^? newPost: Post\n *         this.queryClient.setQueryData([\"posts\", id], newPost);\n *       },\n *     });\n *   }\n * }\n *\n * queries = inject(QueriesService)\n * idSignal = new Signal(0);\n * mutation = injectMutation(() => this.queries.updatePost(this.idSignal()))\n *\n * mutation.mutate({ title: 'New Title' })\n * ```\n * @param options - The mutation options.\n * @returns Mutation options.\n * @public\n */\nexport function mutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n>(\n  options: MutationObserverOptions<TData, TError, TVariables, TContext>,\n): CreateMutationOptions<TData, TError, TVariables, TContext> {\n  return options\n}\n\n/**\n * @public\n */\nexport interface CreateMutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TContext = unknown,\n> extends OmitKeyof<\n    MutationObserverOptions<TData, TError, TVariables, TContext>,\n    '_defaulted'\n  > {}\n"],"names":[],"mappings":"AAqCO,SAAS,gBAMd,SAC4D;AACrD,SAAA;AACT;"}