@tanstack/angular-query 5.0.0-rc.4 → 5.0.0-rc.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. package/hydration-state-key.mjs +10 -13
  2. package/hydration-state-key.mjs.map +1 -1
  3. package/index.mjs +8 -20
  4. package/index.mjs.map +1 -1
  5. package/infinite-query-options.d.ts +7 -18
  6. package/infinite-query-options.mjs +6 -5
  7. package/infinite-query-options.mjs.map +1 -1
  8. package/inject-base-query.d.ts +3 -0
  9. package/inject-base-query.mjs +62 -58
  10. package/inject-base-query.mjs.map +1 -1
  11. package/inject-infinite-query.d.ts +7 -11
  12. package/inject-infinite-query.mjs +16 -32
  13. package/inject-infinite-query.mjs.map +1 -1
  14. package/inject-is-fetching.d.ts +1 -1
  15. package/inject-is-fetching.mjs +22 -15
  16. package/inject-is-fetching.mjs.map +1 -1
  17. package/inject-is-mutating.d.ts +1 -1
  18. package/inject-is-mutating.mjs +22 -15
  19. package/inject-is-mutating.mjs.map +1 -1
  20. package/inject-is-restoring.d.ts +2 -0
  21. package/inject-is-restoring.mjs +28 -17
  22. package/inject-is-restoring.mjs.map +1 -1
  23. package/inject-mutation-state.d.ts +9 -0
  24. package/inject-mutation-state.mjs +25 -23
  25. package/inject-mutation-state.mjs.map +1 -1
  26. package/inject-mutation.d.ts +2 -4
  27. package/inject-mutation.mjs +87 -67
  28. package/inject-mutation.mjs.map +1 -1
  29. package/inject-queries.d.ts +1 -3
  30. package/inject-queries.mjs +122 -114
  31. package/inject-queries.mjs.map +1 -1
  32. package/inject-queries.types.d.ts +15 -0
  33. package/inject-query.d.ts +7 -13
  34. package/inject-query.mjs +11 -14
  35. package/inject-query.mjs.map +1 -1
  36. package/internal.mjs +2 -7
  37. package/mutation-options.d.ts +2 -6
  38. package/mutation-options.mjs +6 -5
  39. package/mutation-options.mjs.map +1 -1
  40. package/package.json +2 -2
  41. package/providers.d.ts +16 -14
  42. package/providers.mjs +138 -75
  43. package/providers.mjs.map +1 -1
  44. package/query-options.d.ts +6 -16
  45. package/query-options.mjs +6 -5
  46. package/query-options.mjs.map +1 -1
  47. package/query-resource.d.ts +4 -3
  48. package/query-resource.mjs +72 -63
  49. package/query-resource.mjs.map +1 -1
  50. package/schematics/migrate-from-experimental/index.js +2 -2
  51. package/schematics/ng-add/index.js +1 -1
  52. package/types.d.ts +70 -10
  53. package/utils/inject-external-store.d.ts +3 -0
  54. package/utils/inject-external-store.mjs +54 -38
  55. package/utils/inject-external-store.mjs.map +1 -1
  56. package/utils/inject-pending-tasks-lifecycle.d.ts +13 -1
  57. package/utils/inject-pending-tasks-lifecycle.mjs +32 -29
  58. package/utils/inject-pending-tasks-lifecycle.mjs.map +1 -1
  59. package/utils/inject-query-zone.d.ts +4 -1
  60. package/utils/inject-query-zone.mjs +12 -7
  61. package/utils/inject-query-zone.mjs.map +1 -1
  62. package/utils/resource-types.d.ts +3 -0
  63. package/utils/result-fields.d.ts +9 -0
  64. package/utils/result-fields.mjs +55 -62
  65. package/utils/result-fields.mjs.map +1 -1
  66. package/utils/signal-proxy.d.ts +6 -0
  67. package/utils/signal-proxy.mjs +16 -9
  68. package/utils/signal-proxy.mjs.map +1 -1
  69. package/internal.mjs.map +0 -1
@@ -1,120 +1,128 @@
1
- import { QueryClient, QueriesObserver } from "@tanstack/query-core";
2
- import { assertInInjectionContext, inject, computed, untracked, effect } from "@angular/core";
3
1
  import { injectQueryZone } from "./utils/inject-query-zone.mjs";
4
- import { signalProxy } from "./utils/signal-proxy.mjs";
5
- import { queryResultFields } from "./utils/result-fields.mjs";
6
2
  import { injectIsRestoring } from "./inject-is-restoring.mjs";
7
3
  import { injectPendingTasksLifecycle } from "./utils/inject-pending-tasks-lifecycle.mjs";
8
4
  import { injectExternalStore } from "./utils/inject-external-store.mjs";
5
+ import { signalProxy } from "./utils/signal-proxy.mjs";
6
+ import { queryResultFields } from "./utils/result-fields.mjs";
7
+ import { QueriesObserver, QueryClient } from "@tanstack/query-core";
8
+ import { assertInInjectionContext, computed, effect, inject, untracked } from "@angular/core";
9
+ //#region src/inject-queries.ts
10
+ /**
11
+ * Injects multiple queries that run in parallel and react to Angular signals.
12
+ * @param optionsFn - A function that returns the queries' options. Similar to `computed` from Angular,
13
+ * this function runs in the reactive context, so signals read inside it drive the queries.
14
+ * @returns A signal containing the query results in the same order as the input queries.
15
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/parallel-queries
16
+ * @example
17
+ * ```angular-ts
18
+ * @Component({
19
+ * selector: 'users',
20
+ * template: `
21
+ * @for (query of userQueries(); track $index) {
22
+ * @if (query.isSuccess()) {
23
+ * <p>{{ query.data().name }}</p>
24
+ * }
25
+ * }
26
+ * `,
27
+ * })
28
+ * export class UsersComponent {
29
+ * readonly users = input.required<Array<User>>()
30
+ *
31
+ * readonly userQueries = injectQueries(() => ({
32
+ * queries: this.users().map((user) => ({
33
+ * queryKey: ['user', user.id],
34
+ * queryFn: () => fetchUserById(user.id),
35
+ * })),
36
+ * }))
37
+ * }
38
+ * ```
39
+ */
9
40
  function injectQueries(optionsFn) {
10
- if (typeof ngDevMode === "undefined" || ngDevMode) {
11
- assertInInjectionContext(injectQueries);
12
- }
13
- const outsideZone = injectQueryZone();
14
- const queryClient = inject(QueryClient);
15
- const isRestoring = injectIsRestoring();
16
- const lifecycle = injectPendingTasksLifecycle();
17
- const optionsSignal = computed(optionsFn);
18
- const defaultedQueries = computed(() => {
19
- return optionsSignal().queries.map((opts) => {
20
- const defaultedOptions = queryClient.defaultQueryOptions(
21
- opts
22
- );
23
- defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
24
- defaultedOptions.notifyOnChangeProps = "all";
25
- return defaultedOptions;
26
- });
27
- });
28
- const shouldBlockPendingTasks = (observer, results) => {
29
- const queries = observer.getQueries();
30
- return results.some((result, index) => {
31
- var _a;
32
- return ((_a = queries[index]) == null ? void 0 : _a.state.fetchStatus) !== "idle" || result.fetchStatus !== "idle" && result.isEnabled;
33
- });
34
- };
35
- const observerSignal = computed(
36
- () => new QueriesObserver(
37
- queryClient,
38
- untracked(defaultedQueries)
39
- )
40
- );
41
- effect(() => {
42
- const queries = defaultedQueries();
43
- outsideZone(() => untracked(() => observerSignal().setQueries(queries)));
44
- });
45
- const refetches = [];
46
- const getRefetch = (index) => refetches[index] ?? (refetches[index] = (options) => outsideZone(
47
- () => untracked(() => {
48
- const observer = observerSignal();
49
- observer.setQueries(defaultedQueries());
50
- const queryObserver = observer.getObservers()[index];
51
- if (!queryObserver) {
52
- return Promise.reject(
53
- new Error(`Cannot refetch removed query at index ${index}`)
54
- );
55
- }
56
- return queryObserver.refetch(options);
57
- })
58
- ));
59
- const resultSignal = injectExternalStore(() => {
60
- const observer = observerSignal();
61
- const restoring = isRestoring();
62
- return {
63
- getSnapshot: () => {
64
- const results = observer.getOptimisticResult(
65
- defaultedQueries(),
66
- void 0
67
- )[0];
68
- refetches.length = results.length;
69
- return results.map((result, index) => ({
70
- ...result,
71
- refetch: getRefetch(index)
72
- }));
73
- },
74
- subscribe: restoring ? void 0 : (onStoreChange) => {
75
- const unsubscribe = observer.subscribe(() => {
76
- if (lifecycle.destroyed) return;
77
- onStoreChange();
78
- });
79
- return () => {
80
- lifecycle.setPending(false);
81
- unsubscribe();
82
- };
83
- }
84
- };
85
- });
86
- effect((onCleanup) => {
87
- const results = resultSignal();
88
- if (isRestoring()) {
89
- lifecycle.setPending(false);
90
- return;
91
- }
92
- lifecycle.setPending(shouldBlockPendingTasks(observerSignal(), results));
93
- onCleanup(() => lifecycle.setPending(false));
94
- });
95
- const createResultProxy = (index) => {
96
- const resultAtIndexSignal = computed(() => resultSignal()[index]);
97
- return Object.assign(signalProxy(resultAtIndexSignal, queryResultFields), {
98
- refetch: getRefetch(index)
99
- });
100
- };
101
- const resultProxies = [];
102
- const proxiedResultsSignal = computed(() => {
103
- const results = resultSignal();
104
- resultProxies.length = results.length;
105
- return results.map((_, index) => {
106
- return resultProxies[index] ?? (resultProxies[index] = createResultProxy(index));
107
- });
108
- });
109
- return computed(() => {
110
- const result = resultSignal();
111
- const { combine } = optionsSignal();
112
- if (combine)
113
- return combine(result);
114
- return proxiedResultsSignal();
115
- });
41
+ if (typeof ngDevMode === "undefined" || ngDevMode) assertInInjectionContext(injectQueries);
42
+ const outsideZone = injectQueryZone();
43
+ const queryClient = inject(QueryClient);
44
+ const isRestoring = injectIsRestoring();
45
+ const lifecycle = injectPendingTasksLifecycle();
46
+ const optionsSignal = computed(optionsFn);
47
+ const defaultedQueries = computed(() => {
48
+ return optionsSignal().queries.map((opts) => {
49
+ const defaultedOptions = queryClient.defaultQueryOptions(opts);
50
+ defaultedOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
51
+ defaultedOptions.notifyOnChangeProps = "all";
52
+ return defaultedOptions;
53
+ });
54
+ });
55
+ const shouldBlockPendingTasks = (observer, results) => {
56
+ const queries = observer.getQueries();
57
+ return results.some((result, index) => {
58
+ return queries[index]?.state.fetchStatus !== "idle" || result.fetchStatus !== "idle" && result.isEnabled;
59
+ });
60
+ };
61
+ const observerSignal = computed(() => new QueriesObserver(queryClient, untracked(defaultedQueries)));
62
+ effect(() => {
63
+ const queries = defaultedQueries();
64
+ outsideZone(() => untracked(() => observerSignal().setQueries(queries)));
65
+ });
66
+ const refetches = [];
67
+ const getRefetch = (index) => refetches[index] ??= (options) => outsideZone(() => untracked(() => {
68
+ const observer = observerSignal();
69
+ observer.setQueries(defaultedQueries());
70
+ const queryObserver = observer.getObservers()[index];
71
+ if (!queryObserver) return Promise.reject(/* @__PURE__ */ new Error(`Cannot refetch removed query at index ${index}`));
72
+ return queryObserver.refetch(options);
73
+ }));
74
+ const resultSignal = injectExternalStore(() => {
75
+ const observer = observerSignal();
76
+ return {
77
+ getSnapshot: () => {
78
+ const results = observer.getOptimisticResult(defaultedQueries(), void 0)[0];
79
+ refetches.length = results.length;
80
+ return results.map((result, index) => ({
81
+ ...result,
82
+ refetch: getRefetch(index)
83
+ }));
84
+ },
85
+ subscribe: isRestoring() ? void 0 : (onStoreChange) => {
86
+ const unsubscribe = observer.subscribe(() => {
87
+ if (lifecycle.destroyed) return;
88
+ onStoreChange();
89
+ });
90
+ return () => {
91
+ lifecycle.setPending(false);
92
+ unsubscribe();
93
+ };
94
+ }
95
+ };
96
+ });
97
+ effect((onCleanup) => {
98
+ const results = resultSignal();
99
+ if (isRestoring()) {
100
+ lifecycle.setPending(false);
101
+ return;
102
+ }
103
+ lifecycle.setPending(shouldBlockPendingTasks(observerSignal(), results));
104
+ onCleanup(() => lifecycle.setPending(false));
105
+ });
106
+ const createResultProxy = (index) => {
107
+ const resultAtIndexSignal = computed(() => resultSignal()[index]);
108
+ return Object.assign(signalProxy(resultAtIndexSignal, queryResultFields), { refetch: getRefetch(index) });
109
+ };
110
+ const resultProxies = [];
111
+ const proxiedResultsSignal = computed(() => {
112
+ const results = resultSignal();
113
+ resultProxies.length = results.length;
114
+ return results.map((_, index) => {
115
+ return resultProxies[index] ??= createResultProxy(index);
116
+ });
117
+ });
118
+ return computed(() => {
119
+ const result = resultSignal();
120
+ const { combine } = optionsSignal();
121
+ if (combine) return combine(result);
122
+ return proxiedResultsSignal();
123
+ });
116
124
  }
117
- export {
118
- injectQueries
119
- };
120
- //# sourceMappingURL=inject-queries.mjs.map
125
+ //#endregion
126
+ export { injectQueries };
127
+
128
+ //# sourceMappingURL=inject-queries.mjs.map
@@ -1 +1 @@
1
- {"version":3,"file":"inject-queries.mjs","sources":["../src/inject-queries.ts"],"sourcesContent":["import { QueriesObserver, QueryClient } from '@tanstack/query-core'\nimport {\n assertInInjectionContext,\n computed,\n effect,\n inject,\n untracked,\n} from '@angular/core'\nimport { injectQueryZone } from './utils/inject-query-zone'\nimport { signalProxy } from './utils/signal-proxy'\nimport { queryResultFields } from './utils/result-fields'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport { injectPendingTasksLifecycle } from './utils/inject-pending-tasks-lifecycle'\nimport { injectExternalStore } from './utils/inject-external-store'\nimport type {\n InjectQueriesOptions,\n QueriesResults,\n} from './inject-queries.types'\nimport type {\n QueryObserverOptions,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\n\n/**\n * Injects multiple queries that run in parallel and react to Angular signals.\n *\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/parallel-queries\n * @param optionsFn - A function that returns the queries' options. Similar to `computed` from Angular,\n * this function runs in the reactive context, so signals read inside it drive the queries.\n * @returns A signal containing the query results in the same order as the input queries.\n *\n * @example\n * ```angular-ts\n * @Component({\n * selector: 'users',\n * template: `\n * @for (query of userQueries(); track $index) {\n * @if (query.isSuccess()) {\n * <p>{{ query.data().name }}</p>\n * }\n * }\n * `,\n * })\n * export class UsersComponent {\n * readonly users = input.required<Array<User>>()\n *\n * readonly userQueries = injectQueries(() => ({\n * queries: this.users().map((user) => ({\n * queryKey: ['user', user.id],\n * queryFn: () => fetchUserById(user.id),\n * })),\n * }))\n * }\n * ```\n */\nexport function injectQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n optionsFn: () => InjectQueriesOptions<T, TCombinedResult>,\n): Signal<TCombinedResult> {\n if (typeof ngDevMode === 'undefined' || ngDevMode) {\n assertInInjectionContext(injectQueries)\n }\n const outsideZone = injectQueryZone()\n const queryClient = inject(QueryClient)\n const isRestoring = injectIsRestoring()\n const lifecycle = injectPendingTasksLifecycle()\n\n const optionsSignal = computed(optionsFn)\n\n const defaultedQueries = computed(() => {\n return optionsSignal().queries.map((opts) => {\n const defaultedOptions = queryClient.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n defaultedOptions._optimisticResults = isRestoring()\n ? 'isRestoring'\n : 'optimistic'\n defaultedOptions.notifyOnChangeProps = 'all'\n\n return defaultedOptions as QueryObserverOptions\n })\n })\n\n const shouldBlockPendingTasks = (\n observer: QueriesObserver<TCombinedResult>,\n results: Array<QueryObserverResult>,\n ) => {\n const queries = observer.getQueries()\n\n return results.some((result, index) => {\n return (\n queries[index]?.state.fetchStatus !== 'idle' ||\n (result.fetchStatus !== 'idle' && result.isEnabled)\n )\n })\n }\n\n const observerSignal = computed(\n () =>\n new QueriesObserver<TCombinedResult>(\n queryClient,\n untracked(defaultedQueries),\n ),\n )\n\n effect(() => {\n const queries = defaultedQueries()\n outsideZone(() => untracked(() => observerSignal().setQueries(queries)))\n })\n\n // Methods address the current array slot, including methods handed to combine.\n const refetches: Array<QueryObserverResult['refetch']> = []\n const getRefetch = (index: number): QueryObserverResult['refetch'] =>\n (refetches[index] ??= (options) =>\n outsideZone(() =>\n untracked(() => {\n const observer = observerSignal()\n observer.setQueries(defaultedQueries())\n const queryObserver = observer.getObservers()[index]\n if (!queryObserver) {\n return Promise.reject(\n new Error(`Cannot refetch removed query at index ${index}`),\n )\n }\n return queryObserver.refetch(options)\n }),\n ))\n\n const resultSignal = injectExternalStore(() => {\n const observer = observerSignal()\n const restoring = isRestoring()\n return {\n getSnapshot: () => {\n const results = observer.getOptimisticResult(\n defaultedQueries(),\n undefined,\n )[0]\n refetches.length = results.length\n return results.map((result, index) => ({\n ...result,\n refetch: getRefetch(index),\n }))\n },\n subscribe: restoring\n ? undefined\n : (onStoreChange) => {\n const unsubscribe = observer.subscribe(() => {\n if (lifecycle.destroyed) return\n onStoreChange()\n })\n return () => {\n lifecycle.setPending(false)\n unsubscribe()\n }\n },\n }\n })\n\n effect((onCleanup) => {\n const results = resultSignal()\n if (isRestoring()) {\n lifecycle.setPending(false)\n return\n }\n\n lifecycle.setPending(shouldBlockPendingTasks(observerSignal(), results))\n onCleanup(() => lifecycle.setPending(false))\n })\n\n const createResultProxy = (index: number) => {\n const resultAtIndexSignal = computed(() => resultSignal()[index]!)\n return Object.assign(signalProxy(resultAtIndexSignal, queryResultFields), {\n refetch: getRefetch(index),\n })\n }\n\n const resultProxies: Array<ReturnType<typeof createResultProxy>> = []\n const proxiedResultsSignal = computed(() => {\n const results = resultSignal()\n resultProxies.length = results.length\n\n return results.map((_, index) => {\n return (resultProxies[index] ??= createResultProxy(index))\n })\n })\n\n // Combine in Angular's tracked computation. Core must notify for every raw\n // result change, including changes a previous combine function ignored.\n return computed(() => {\n const result = resultSignal()\n const { combine } = optionsSignal()\n\n if (combine)\n return combine(result as Parameters<NonNullable<typeof combine>>[0])\n\n return proxiedResultsSignal() as unknown as TCombinedResult\n }) as unknown as Signal<TCombinedResult>\n}\n"],"names":[],"mappings":"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"}
1
+ {"version":3,"file":"inject-queries.mjs","names":[],"sources":["../src/inject-queries.ts"],"sourcesContent":["import { QueriesObserver, QueryClient } from '@tanstack/query-core'\nimport {\n assertInInjectionContext,\n computed,\n effect,\n inject,\n untracked,\n} from '@angular/core'\nimport { injectQueryZone } from './utils/inject-query-zone'\nimport { signalProxy } from './utils/signal-proxy'\nimport { queryResultFields } from './utils/result-fields'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport { injectPendingTasksLifecycle } from './utils/inject-pending-tasks-lifecycle'\nimport { injectExternalStore } from './utils/inject-external-store'\nimport type {\n InjectQueriesOptions,\n QueriesResults,\n} from './inject-queries.types'\nimport type {\n QueryObserverOptions,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { Signal } from '@angular/core'\n\n/**\n * Injects multiple queries that run in parallel and react to Angular signals.\n * @param optionsFn - A function that returns the queries' options. Similar to `computed` from Angular,\n * this function runs in the reactive context, so signals read inside it drive the queries.\n * @returns A signal containing the query results in the same order as the input queries.\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/parallel-queries\n * @example\n * ```angular-ts\n * @Component({\n * selector: 'users',\n * template: `\n * @for (query of userQueries(); track $index) {\n * @if (query.isSuccess()) {\n * <p>{{ query.data().name }}</p>\n * }\n * }\n * `,\n * })\n * export class UsersComponent {\n * readonly users = input.required<Array<User>>()\n *\n * readonly userQueries = injectQueries(() => ({\n * queries: this.users().map((user) => ({\n * queryKey: ['user', user.id],\n * queryFn: () => fetchUserById(user.id),\n * })),\n * }))\n * }\n * ```\n */\nexport function injectQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n optionsFn: () => InjectQueriesOptions<T, TCombinedResult>,\n): Signal<TCombinedResult> {\n if (typeof ngDevMode === 'undefined' || ngDevMode) {\n assertInInjectionContext(injectQueries)\n }\n const outsideZone = injectQueryZone()\n const queryClient = inject(QueryClient)\n const isRestoring = injectIsRestoring()\n const lifecycle = injectPendingTasksLifecycle()\n\n const optionsSignal = computed(optionsFn)\n\n const defaultedQueries = computed(() => {\n return optionsSignal().queries.map((opts) => {\n const defaultedOptions = queryClient.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n defaultedOptions._optimisticResults = isRestoring()\n ? 'isRestoring'\n : 'optimistic'\n defaultedOptions.notifyOnChangeProps = 'all'\n\n return defaultedOptions\n })\n })\n\n const shouldBlockPendingTasks = (\n observer: QueriesObserver<TCombinedResult>,\n results: Array<QueryObserverResult>,\n ) => {\n const queries = observer.getQueries()\n\n return results.some((result, index) => {\n return (\n queries[index]?.state.fetchStatus !== 'idle' ||\n (result.fetchStatus !== 'idle' && result.isEnabled)\n )\n })\n }\n\n const observerSignal = computed(\n () =>\n new QueriesObserver<TCombinedResult>(\n queryClient,\n untracked(defaultedQueries),\n ),\n )\n\n effect(() => {\n const queries = defaultedQueries()\n outsideZone(() => untracked(() => observerSignal().setQueries(queries)))\n })\n\n // Methods address the current array slot, including methods handed to combine.\n const refetches: Array<QueryObserverResult['refetch']> = []\n const getRefetch = (index: number): QueryObserverResult['refetch'] =>\n (refetches[index] ??= (options) =>\n outsideZone(() =>\n untracked(() => {\n const observer = observerSignal()\n observer.setQueries(defaultedQueries())\n const queryObserver = observer.getObservers()[index]\n if (!queryObserver) {\n return Promise.reject(\n new Error(`Cannot refetch removed query at index ${index}`),\n )\n }\n return queryObserver.refetch(options)\n }),\n ))\n\n const resultSignal = injectExternalStore(() => {\n const observer = observerSignal()\n const restoring = isRestoring()\n return {\n getSnapshot: () => {\n const results = observer.getOptimisticResult(\n defaultedQueries(),\n undefined,\n )[0]\n refetches.length = results.length\n return results.map((result, index) => ({\n ...result,\n refetch: getRefetch(index),\n }))\n },\n subscribe: restoring\n ? undefined\n : (onStoreChange) => {\n const unsubscribe = observer.subscribe(() => {\n if (lifecycle.destroyed) return\n onStoreChange()\n })\n return () => {\n lifecycle.setPending(false)\n unsubscribe()\n }\n },\n }\n })\n\n effect((onCleanup) => {\n const results = resultSignal()\n if (isRestoring()) {\n lifecycle.setPending(false)\n return\n }\n\n lifecycle.setPending(shouldBlockPendingTasks(observerSignal(), results))\n onCleanup(() => lifecycle.setPending(false))\n })\n\n const createResultProxy = (index: number) => {\n const resultAtIndexSignal = computed(() => resultSignal()[index]!)\n return Object.assign(signalProxy(resultAtIndexSignal, queryResultFields), {\n refetch: getRefetch(index),\n })\n }\n\n const resultProxies: Array<ReturnType<typeof createResultProxy>> = []\n const proxiedResultsSignal = computed(() => {\n const results = resultSignal()\n resultProxies.length = results.length\n\n return results.map((_, index) => {\n return (resultProxies[index] ??= createResultProxy(index))\n })\n })\n\n // Combine in Angular's tracked computation. Core must notify for every raw\n // result change, including changes a previous combine function ignored.\n return computed(() => {\n const result = resultSignal()\n const { combine } = optionsSignal()\n\n if (combine)\n return combine(result as Parameters<NonNullable<typeof combine>>[0])\n\n return proxiedResultsSignal() as unknown as TCombinedResult\n })\n}\n"],"mappings":"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"}
@@ -68,6 +68,9 @@ type InferDataAndError<T> = T extends {
68
68
  };
69
69
  type GetCreateQueryResult<T> = GenericGetDefinedOrUndefinedQueryResult<T, InferDataAndError<T>['data'], CreateQueryResult<InferDataAndError<T>['data'], InferDataAndError<T>['error']>, DefinedCreateQueryResult<InferDataAndError<T>['data'], InferDataAndError<T>['error']>>;
70
70
  type GetQueryObserverResult<T> = GenericGetDefinedOrUndefinedQueryResult<T, InferDataAndError<T>['data'], QueryObserverResult<InferDataAndError<T>['data'], InferDataAndError<T>['error']>, DefinedQueryObserverResult<InferDataAndError<T>['data'], InferDataAndError<T>['error']>>;
71
+ /**
72
+ * Maps a tuple of query descriptions to the options accepted by `injectQueries`.
73
+ */
71
74
  export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
72
75
  ...Tails
73
76
  ], [
@@ -77,6 +80,9 @@ export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [
77
80
  ...TDepth,
78
81
  1
79
82
  ]> : 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>;
83
+ /**
84
+ * Maps a tuple of query descriptions to their individual signal-backed results.
85
+ */
80
86
  export type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
81
87
  ...Tails
82
88
  ], [
@@ -99,12 +105,21 @@ type RawQueriesResults<T extends Array<any>, TResults extends Array<any> = [], T
99
105
  ]> : {
100
106
  [K in keyof T]: GetQueryObserverResult<T[K]>;
101
107
  };
108
+ /**
109
+ * A reactive group of query options and an optional projection of their combined results.
110
+ */
102
111
  export interface InjectQueriesOptions<T extends Array<any>, TCombinedResult = QueriesResults<T>> {
112
+ /**
113
+ * The ordered query options to observe; entries can be added, removed, or replaced reactively.
114
+ */
103
115
  queries: readonly [...QueriesOptions<T>] | readonly [
104
116
  ...{
105
117
  [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]>;
106
118
  }
107
119
  ];
120
+ /**
121
+ * Projects the current plain observer results into a single reactively computed value.
122
+ */
108
123
  combine?: (result: RawQueriesResults<T>) => TCombinedResult;
109
124
  }
110
125
  export {};
package/inject-query.d.ts CHANGED
@@ -4,16 +4,14 @@ import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-
4
4
  /**
5
5
  * This overload is selected when `initialData` is set on the options returned by `optionsFn`, so the
6
6
  * resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).
7
- *
8
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
9
- * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like
10
- * `queryClient.query`.
11
7
  * @param optionsFn - A function returning the {@link DefinedInitialDataOptions} to use — everything you
12
8
  * can pass to `injectQuery`, with `initialData` set. Similar to `computed` from Angular, this function runs
13
9
  * in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.
14
10
  * @returns The query result, typed so that `data` is never `undefined` (unless a `select` changes `TData` to
15
11
  * include `undefined`).
16
- *
12
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
13
+ * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like
14
+ * `queryClient.query`.
17
15
  * @example
18
16
  * ```angular-ts
19
17
  * @Component({
@@ -43,17 +41,15 @@ import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-
43
41
  export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedCreateQueryResult<TData, TError>;
44
42
  /**
45
43
  * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
46
- *
47
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
48
- * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like
49
- * `queryClient.query`.
50
44
  * @param optionsFn - A function returning the {@link UndefinedInitialDataOptions} to use — everything
51
45
  * you can pass to `injectQuery`. Similar to `computed` from Angular, this function runs in the reactive
52
46
  * context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.
53
47
  * @returns The query result. `status()` is `'pending'` if there is no cached data to display, `'error'` if
54
48
  * the last fetch attempt failed, or `'success'` if the query has data to display. `isPending`/`isSuccess`/
55
49
  * `isError` are type-guard methods for convenience.
56
- *
50
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
51
+ * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like
52
+ * `queryClient.query`.
57
53
  * @example
58
54
  * ```angular-ts
59
55
  * @Component({
@@ -79,7 +75,6 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
79
75
  * }))
80
76
  * }
81
77
  * ```
82
- *
83
78
  * @example
84
79
  * Similar to `computed` from Angular, the function passed to `injectQuery` runs in the reactive context. In
85
80
  * the example below, the query is automatically enabled and executed when the filter signal changes to a
@@ -118,10 +113,9 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
118
113
  * This overload accepts the general {@link CreateQueryOptions} shape rather than the `initialData`-aware
119
114
  * overloads above, so whether `data` is defined can't be inferred from the call site — useful when wrapping
120
115
  * `injectQuery` in your own helper function that forwards caller-provided options.
121
- *
122
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
123
116
  * @param optionsFn - A function that returns query options. Similar to `computed` from Angular, this
124
117
  * function runs in the reactive context, so signals read inside it drive the query.
125
118
  * @returns The query result.
119
+ * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
126
120
  */
127
121
  export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(optionsFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>): CreateQueryResult<TData, TError>;
package/inject-query.mjs CHANGED
@@ -1,20 +1,17 @@
1
- import { QueryObserver } from "@tanstack/query-core";
2
- import { assertInInjectionContext, untracked } from "@angular/core";
3
1
  import { injectQueryZone } from "./utils/inject-query-zone.mjs";
4
2
  import { injectBaseQuery } from "./inject-base-query.mjs";
5
3
  import { signalProxy } from "./utils/signal-proxy.mjs";
6
4
  import { queryResultFields } from "./utils/result-fields.mjs";
5
+ import { QueryObserver } from "@tanstack/query-core";
6
+ import { assertInInjectionContext, untracked } from "@angular/core";
7
+ //#region src/inject-query.ts
7
8
  function injectQuery(optionsFn) {
8
- if (typeof ngDevMode === "undefined" || ngDevMode) {
9
- assertInInjectionContext(injectQuery);
10
- }
11
- const outsideZone = injectQueryZone();
12
- const [resultSignal, getObserver] = injectBaseQuery(optionsFn, QueryObserver);
13
- return Object.assign(signalProxy(resultSignal, queryResultFields), {
14
- refetch: (options) => outsideZone(() => untracked(() => getObserver().refetch(options)))
15
- });
9
+ if (typeof ngDevMode === "undefined" || ngDevMode) assertInInjectionContext(injectQuery);
10
+ const outsideZone = injectQueryZone();
11
+ const [resultSignal, getObserver] = injectBaseQuery(optionsFn, QueryObserver);
12
+ return Object.assign(signalProxy(resultSignal, queryResultFields), { refetch: (options) => outsideZone(() => untracked(() => getObserver().refetch(options))) });
16
13
  }
17
- export {
18
- injectQuery
19
- };
20
- //# sourceMappingURL=inject-query.mjs.map
14
+ //#endregion
15
+ export { injectQuery };
16
+
17
+ //# sourceMappingURL=inject-query.mjs.map
@@ -1 +1 @@
1
- {"version":3,"file":"inject-query.mjs","sources":["../src/inject-query.ts"],"sourcesContent":["import { QueryObserver } from '@tanstack/query-core'\nimport { assertInInjectionContext, untracked } from '@angular/core'\nimport { injectQueryZone } from './utils/inject-query-zone'\nimport { injectBaseQuery } from './inject-base-query'\nimport { signalProxy } from './utils/signal-proxy'\nimport { queryResultFields } from './utils/result-fields'\nimport type {\n DefaultError,\n QueryKey,\n RefetchOptions,\n} 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\n/**\n * This overload is selected when `initialData` is set on the options returned by `optionsFn`, so the\n * resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).\n *\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like\n * `queryClient.query`.\n * @param optionsFn - A function returning the {@link DefinedInitialDataOptions} to use — everything you\n * can pass to `injectQuery`, with `initialData` set. Similar to `computed` from Angular, this function runs\n * in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.\n * @returns The query result, typed so that `data` is never `undefined` (unless a `select` changes `TData` to\n * include `undefined`).\n *\n * @example\n * ```angular-ts\n * @Component({\n * selector: 'posts',\n * template: `\n * <!-- `postsQuery.data()` is `Post[]`, never `undefined`, thanks to `initialData` — even if a\n * refetch fails, so the list stays visible alongside the error. -->\n * @if (postsQuery.isError()) {\n * <span>Error: {{ postsQuery.error()?.message }}</span>\n * }\n * <ul>\n * @for (post of postsQuery.data(); track post.id) {\n * <li>{{ post.title }}</li>\n * }\n * </ul>\n * `,\n * })\n * export class Posts {\n * readonly postsQuery = injectQuery(() => ({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * initialData: [],\n * }))\n * }\n * ```\n */\nexport function injectQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n optionsFn: () => DefinedInitialDataOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >,\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 * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like\n * `queryClient.query`.\n * @param optionsFn - A function returning the {@link UndefinedInitialDataOptions} to use — everything\n * you can pass to `injectQuery`. Similar to `computed` from Angular, this function runs in the reactive\n * context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.\n * @returns The query result. `status()` is `'pending'` if there is no cached data to display, `'error'` if\n * the last fetch attempt failed, or `'success'` if the query has data to display. `isPending`/`isSuccess`/\n * `isError` are type-guard methods for convenience.\n *\n * @example\n * ```angular-ts\n * @Component({\n * selector: 'posts',\n * template: `\n * @if (postsQuery.isPending()) {\n * Loading...\n * } @else if (postsQuery.isError()) {\n * <span>Error: {{ postsQuery.error()?.message }}</span>\n * } @else {\n * <ul>\n * @for (post of postsQuery.data(); track post.id) {\n * <li>{{ post.title }}</li>\n * }\n * </ul>\n * }\n * `,\n * })\n * export class Posts {\n * readonly postsQuery = injectQuery(() => ({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * }))\n * }\n * ```\n *\n * @example\n * Similar to `computed` from Angular, the function passed to `injectQuery` runs in the reactive context. In\n * the example below, the query is automatically enabled and executed when the filter signal changes to a\n * truthy value. When the filter signal changes back to a falsy value, the query is disabled.\n * ```angular-ts\n * @Component({\n * selector: 'posts',\n * template: `\n * <input [ngModel]=\"filter()\" (ngModelChange)=\"filter.set($event)\" />\n * @if (postsQuery.isPending()) {\n * Loading...\n * } @else if (postsQuery.isError()) {\n * <span>Error: {{ postsQuery.error()?.message }}</span>\n * } @else {\n * <ul>\n * @for (post of postsQuery.data(); track post.id) {\n * <li>{{ post.title }}</li>\n * }\n * </ul>\n * }\n * `,\n * })\n * export class Posts {\n * readonly filter = signal('')\n *\n * readonly postsQuery = injectQuery(() => ({\n * queryKey: ['posts', this.filter()],\n * queryFn: () => fetchPosts(this.filter()),\n * enabled: !!this.filter(),\n * }))\n * }\n * ```\n */\nexport function injectQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n optionsFn: () => UndefinedInitialDataOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >,\n): CreateQueryResult<TData, TError>\n\n/**\n * This overload accepts the general {@link CreateQueryOptions} shape rather than the `initialData`-aware\n * overloads above, so whether `data` is defined can't be inferred from the call site — useful when wrapping\n * `injectQuery` in your own helper function that forwards caller-provided options.\n *\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @param optionsFn - A function that returns query options. Similar to `computed` from Angular, this\n * function runs in the reactive context, so signals read inside it drive the query.\n * @returns The query result.\n */\nexport function injectQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n optionsFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n): CreateQueryResult<TData, TError>\n\nexport function injectQuery(\n optionsFn: () => CreateQueryOptions,\n): DefinedCreateQueryResult | CreateQueryResult {\n if (typeof ngDevMode === 'undefined' || ngDevMode) {\n assertInInjectionContext(injectQuery)\n }\n const outsideZone = injectQueryZone()\n const [resultSignal, getObserver] = injectBaseQuery(optionsFn, QueryObserver)\n return Object.assign(signalProxy(resultSignal, queryResultFields), {\n refetch: (options?: RefetchOptions) =>\n outsideZone(() => untracked(() => getObserver().refetch(options))),\n }) as unknown as DefinedCreateQueryResult | CreateQueryResult\n}\n"],"names":[],"mappings":";;;;;;AAmLO,SAAS,YACd,WAC8C;AAC9C,MAAI,OAAO,cAAc,eAAe,WAAW;AACjD,6BAAyB,WAAW;AAAA,EACtC;AACA,QAAM,cAAc,gBAAA;AACpB,QAAM,CAAC,cAAc,WAAW,IAAI,gBAAgB,WAAW,aAAa;AAC5E,SAAO,OAAO,OAAO,YAAY,cAAc,iBAAiB,GAAG;AAAA,IACjE,SAAS,CAAC,YACR,YAAY,MAAM,UAAU,MAAM,YAAA,EAAc,QAAQ,OAAO,CAAC,CAAC;AAAA,EAAA,CACpE;AACH;"}
1
+ {"version":3,"file":"inject-query.mjs","names":[],"sources":["../src/inject-query.ts"],"sourcesContent":["import { QueryObserver } from '@tanstack/query-core'\nimport { assertInInjectionContext, untracked } from '@angular/core'\nimport { injectQueryZone } from './utils/inject-query-zone'\nimport { injectBaseQuery } from './inject-base-query'\nimport { signalProxy } from './utils/signal-proxy'\nimport { queryResultFields } from './utils/result-fields'\nimport type {\n DefaultError,\n QueryKey,\n RefetchOptions,\n} 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\n/**\n * This overload is selected when `initialData` is set on the options returned by `optionsFn`, so the\n * resulting `data` signal is never `undefined` (unless a `select` changes `TData` to include `undefined`).\n * @param optionsFn - A function returning the {@link DefinedInitialDataOptions} to use — everything you\n * can pass to `injectQuery`, with `initialData` set. Similar to `computed` from Angular, this function runs\n * in the reactive context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.\n * @returns The query result, typed so that `data` is never `undefined` (unless a `select` changes `TData` to\n * include `undefined`).\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like\n * `queryClient.query`.\n * @example\n * ```angular-ts\n * @Component({\n * selector: 'posts',\n * template: `\n * <!-- `postsQuery.data()` is `Post[]`, never `undefined`, thanks to `initialData` — even if a\n * refetch fails, so the list stays visible alongside the error. -->\n * @if (postsQuery.isError()) {\n * <span>Error: {{ postsQuery.error()?.message }}</span>\n * }\n * <ul>\n * @for (post of postsQuery.data(); track post.id) {\n * <li>{{ post.title }}</li>\n * }\n * </ul>\n * `,\n * })\n * export class Posts {\n * readonly postsQuery = injectQuery(() => ({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * initialData: [],\n * }))\n * }\n * ```\n */\nexport function injectQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n optionsFn: () => DefinedInitialDataOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >,\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 * @param optionsFn - A function returning the {@link UndefinedInitialDataOptions} to use — everything\n * you can pass to `injectQuery`. Similar to `computed` from Angular, this function runs in the reactive\n * context, so signals read inside it (in `queryKey`, `enabled`, etc.) drive the query.\n * @returns The query result. `status()` is `'pending'` if there is no cached data to display, `'error'` if\n * the last fetch attempt failed, or `'success'` if the query has data to display. `isPending`/`isSuccess`/\n * `isError` are type-guard methods for convenience.\n * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries\n * @see {@link queryOptions} to share these options between `injectQuery` and imperative APIs like\n * `queryClient.query`.\n * @example\n * ```angular-ts\n * @Component({\n * selector: 'posts',\n * template: `\n * @if (postsQuery.isPending()) {\n * Loading...\n * } @else if (postsQuery.isError()) {\n * <span>Error: {{ postsQuery.error()?.message }}</span>\n * } @else {\n * <ul>\n * @for (post of postsQuery.data(); track post.id) {\n * <li>{{ post.title }}</li>\n * }\n * </ul>\n * }\n * `,\n * })\n * export class Posts {\n * readonly postsQuery = injectQuery(() => ({\n * queryKey: ['posts'],\n * queryFn: fetchPosts,\n * }))\n * }\n * ```\n * @example\n * Similar to `computed` from Angular, the function passed to `injectQuery` runs in the reactive context. In\n * the example below, the query is automatically enabled and executed when the filter signal changes to a\n * truthy value. When the filter signal changes back to a falsy value, the query is disabled.\n * ```angular-ts\n * @Component({\n * selector: 'posts',\n * template: `\n * <input [ngModel]=\"filter()\" (ngModelChange)=\"filter.set($event)\" />\n * @if (postsQuery.isPending()) {\n * Loading...\n * } @else if (postsQuery.isError()) {\n * <span>Error: {{ postsQuery.error()?.message }}</span>\n * } @else {\n * <ul>\n * @for (post of postsQuery.data(); track post.id) {\n * <li>{{ post.title }}</li>\n * }\n * </ul>\n * }\n * `,\n * })\n * export class Posts {\n * readonly filter = signal('')\n *\n * readonly postsQuery = injectQuery(() => ({\n * queryKey: ['posts', this.filter()],\n * queryFn: () => fetchPosts(this.filter()),\n * enabled: !!this.filter(),\n * }))\n * }\n * ```\n */\nexport function injectQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n optionsFn: () => UndefinedInitialDataOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >,\n): CreateQueryResult<TData, TError>\n\n/**\n * This overload accepts the general {@link CreateQueryOptions} shape rather than the `initialData`-aware\n * overloads above, so whether `data` is defined can't be inferred from the call site — useful when wrapping\n * `injectQuery` in your own helper function that forwards caller-provided options.\n * @param optionsFn - A function that returns query options. Similar to `computed` from Angular, this\n * function runs in the reactive context, so signals read inside it drive the query.\n * @returns The query result.\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 optionsFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n): CreateQueryResult<TData, TError>\n\nexport function injectQuery(\n optionsFn: () => CreateQueryOptions,\n): DefinedCreateQueryResult | CreateQueryResult {\n if (typeof ngDevMode === 'undefined' || ngDevMode) {\n assertInInjectionContext(injectQuery)\n }\n const outsideZone = injectQueryZone()\n const [resultSignal, getObserver] = injectBaseQuery(optionsFn, QueryObserver)\n return Object.assign(signalProxy(resultSignal, queryResultFields), {\n refetch: (options?: RefetchOptions) =>\n outsideZone(() => untracked(() => getObserver().refetch(options))),\n }) as unknown as DefinedCreateQueryResult | CreateQueryResult\n}\n"],"mappings":";;;;;;;AA6KA,SAAgB,YACd,WAC8C;CAC9C,IAAI,OAAO,cAAc,eAAe,WACtC,yBAAyB,WAAW;CAEtC,MAAM,cAAc,gBAAgB;CACpC,MAAM,CAAC,cAAc,eAAe,gBAAgB,WAAW,aAAa;CAC5E,OAAO,OAAO,OAAO,YAAY,cAAc,iBAAiB,GAAG,EACjE,UAAU,YACR,kBAAkB,gBAAgB,YAAY,CAAC,CAAC,QAAQ,OAAO,CAAC,CAAC,EACrE,CAAC;AACH"}
package/internal.mjs CHANGED
@@ -1,8 +1,3 @@
1
- import { getQueryFeatureProviders, queryFeature } from "./providers.mjs";
2
1
  import { provideIsRestoring } from "./inject-is-restoring.mjs";
3
- export {
4
- getQueryFeatureProviders,
5
- provideIsRestoring,
6
- queryFeature
7
- };
8
- //# sourceMappingURL=internal.mjs.map
2
+ import { getQueryFeatureProviders, queryFeature } from "./providers.mjs";
3
+ export { getQueryFeatureProviders, provideIsRestoring, queryFeature };
@@ -4,12 +4,10 @@ import { CreateMutationOptions } from './types.js';
4
4
  * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. A
5
5
  * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with
6
6
  * `injectMutationState`.
7
- *
8
- * @see {@link injectMutation} to run the mutation these options describe.
9
7
  * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, with a
10
8
  * required `mutationKey`.
11
9
  * @returns The same options object, unchanged.
12
- *
10
+ * @see {@link injectMutation} to run the mutation these options describe.
13
11
  * @example
14
12
  * Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global "saving…" indicator:
15
13
  * ```angular-ts
@@ -42,13 +40,11 @@ export declare function mutationOptions<TData = unknown, TError = DefaultError,
42
40
  * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a
43
41
  * `mutationKey` filter later (e.g. with `injectMutationState`); it can still be observed through other
44
42
  * filters, such as `status`.
45
- *
46
- * @see {@link injectMutation} to run the mutation these options describe.
47
43
  * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, without a
48
44
  * `mutationKey`.
49
45
  * @returns The same options object, unchanged.
50
46
  * @remarks See the other overload's example for looking a mutation up via `injectMutationState`.
51
- *
47
+ * @see {@link injectMutation} to run the mutation these options describe.
52
48
  * @example
53
49
  * Sharing options across services, so `QueriesService` stays the single place a mutation is defined:
54
50
  * ```angular-ts
@@ -1,7 +1,8 @@
1
+ //#region src/mutation-options.ts
1
2
  function mutationOptions(options) {
2
- return options;
3
+ return options;
3
4
  }
4
- export {
5
- mutationOptions
6
- };
7
- //# sourceMappingURL=mutation-options.mjs.map
5
+ //#endregion
6
+ export { mutationOptions };
7
+
8
+ //# sourceMappingURL=mutation-options.mjs.map
@@ -1 +1 @@
1
- {"version":3,"file":"mutation-options.mjs","sources":["../src/mutation-options.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { CreateMutationOptions } from './types'\n\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. A\n * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with\n * `injectMutationState`.\n *\n * @see {@link injectMutation} to run the mutation these options describe.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, with a\n * required `mutationKey`.\n * @returns The same options object, unchanged.\n *\n * @example\n * Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global \"saving…\" indicator:\n * ```angular-ts\n * import { mutationOptions, injectMutationState } from '@tanstack/angular-query'\n *\n * const createPostOptions = mutationOptions({\n * mutationKey: ['posts', 'create'],\n * mutationFn: createPost,\n * })\n *\n * @Component({\n * selector: 'saving-indicator',\n * template: `\n * @if (isCreatingPost()) {\n * <span>Saving…</span>\n * }\n * `,\n * })\n * export class SavingIndicator {\n * readonly #pendingCreates = injectMutationState(() => ({\n * filters: { mutationKey: createPostOptions.mutationKey, status: 'pending' },\n * }))\n * readonly isCreatingPost = computed(() => this.#pendingCreates().length > 0)\n * }\n * ```\n */\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. No\n * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a\n * `mutationKey` filter later (e.g. with `injectMutationState`); it can still be observed through other\n * filters, such as `status`.\n *\n * @see {@link injectMutation} to run the mutation these options describe.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, without a\n * `mutationKey`.\n * @returns The same options object, unchanged.\n * @remarks See the other overload's example for looking a mutation up via `injectMutationState`.\n *\n * @example\n * Sharing options across services, so `QueriesService` stays the single place a mutation is defined:\n * ```angular-ts\n * import { mutationOptions, injectMutation } from '@tanstack/angular-query'\n *\n * @Injectable({ providedIn: 'root' })\n * export class QueriesService {\n * readonly #queryClient = inject(QueryClient)\n *\n * updatePost(id: number) {\n * return mutationOptions({\n * mutationFn: (post: Partial<Post>) => putPost(id, post),\n * onSuccess: (newPost) => this.#queryClient.setQueryData(['posts', id], newPost),\n * })\n * }\n * }\n *\n * @Component({\n * selector: 'post',\n * template: `<button (click)=\"save()\">Save</button>`,\n * })\n * export class Post {\n * readonly queries = inject(QueriesService)\n * readonly id = signal(0)\n * readonly updatePostMutation = injectMutation(() => this.queries.updatePost(this.id()))\n *\n * save() {\n * this.updatePostMutation.mutate({ title: 'New Title' })\n * }\n * }\n * ```\n */\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): CreateMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"names":[],"mappings":"AA+GO,SAAS,gBAMd,SACmE;AACnE,SAAO;AACT;"}
1
+ {"version":3,"file":"mutation-options.mjs","names":[],"sources":["../src/mutation-options.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { CreateMutationOptions } from './types'\n\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. A\n * `mutationKey` is required on this overload so the mutation can be looked up later, e.g. with\n * `injectMutationState`.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, with a\n * required `mutationKey`.\n * @returns The same options object, unchanged.\n * @see {@link injectMutation} to run the mutation these options describe.\n * @example\n * Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global \"saving…\" indicator:\n * ```angular-ts\n * import { mutationOptions, injectMutationState } from '@tanstack/angular-query'\n *\n * const createPostOptions = mutationOptions({\n * mutationKey: ['posts', 'create'],\n * mutationFn: createPost,\n * })\n *\n * @Component({\n * selector: 'saving-indicator',\n * template: `\n * @if (isCreatingPost()) {\n * <span>Saving…</span>\n * }\n * `,\n * })\n * export class SavingIndicator {\n * readonly #pendingCreates = injectMutationState(() => ({\n * filters: { mutationKey: createPostOptions.mutationKey, status: 'pending' },\n * }))\n * readonly isCreatingPost = computed(() => this.#pendingCreates().length > 0)\n * }\n * ```\n */\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\n/**\n * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. No\n * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a\n * `mutationKey` filter later (e.g. with `injectMutationState`); it can still be observed through other\n * filters, such as `status`.\n * @param options - The mutation options to use, identical to what you'd pass to `injectMutation`, without a\n * `mutationKey`.\n * @returns The same options object, unchanged.\n * @remarks See the other overload's example for looking a mutation up via `injectMutationState`.\n * @see {@link injectMutation} to run the mutation these options describe.\n * @example\n * Sharing options across services, so `QueriesService` stays the single place a mutation is defined:\n * ```angular-ts\n * import { mutationOptions, injectMutation } from '@tanstack/angular-query'\n *\n * @Injectable({ providedIn: 'root' })\n * export class QueriesService {\n * readonly #queryClient = inject(QueryClient)\n *\n * updatePost(id: number) {\n * return mutationOptions({\n * mutationFn: (post: Partial<Post>) => putPost(id, post),\n * onSuccess: (newPost) => this.#queryClient.setQueryData(['posts', id], newPost),\n * })\n * }\n * }\n *\n * @Component({\n * selector: 'post',\n * template: `<button (click)=\"save()\">Save</button>`,\n * })\n * export class Post {\n * readonly queries = inject(QueriesService)\n * readonly id = signal(0)\n * readonly updatePostMutation = injectMutation(() => this.queries.updatePost(this.id()))\n *\n * save() {\n * this.updatePostMutation.mutate({ title: 'New Title' })\n * }\n * }\n * ```\n */\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): CreateMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";AA2GA,SAAgB,gBAMd,SACmE;CACnE,OAAO;AACT"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@tanstack/angular-query",
3
- "version": "5.0.0-rc.4",
3
+ "version": "5.0.0-rc.5",
4
4
  "description": "Signals for managing, caching and syncing asynchronous and remote data in Angular",
5
5
  "author": "Arnoud de Vries",
6
6
  "license": "MIT",
@@ -45,7 +45,7 @@
45
45
  },
46
46
  "sideEffects": false,
47
47
  "dependencies": {
48
- "@tanstack/query-core": "5.103.2"
48
+ "@tanstack/query-core": "5.104.3"
49
49
  },
50
50
  "peerDependencies": {
51
51
  "@angular/common": ">=20.1.0",