npm - @tanstack/angular-query-experimental - Versions diffs - 5.80.7 → 5.80.8 - Mend

@tanstack/angular-query-experimental 5.80.7 → 5.80.8

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 (90) hide show

package/dist/create-base-query.mjs +74 -0
package/dist/create-base-query.mjs.map +1 -0
package/dist/index.mjs +35 -0
package/dist/index.mjs.map +1 -0
package/dist/infinite-query-options.mjs +7 -0
package/dist/infinite-query-options.mjs.map +1 -0
package/dist/inject-infinite-query.mjs +18 -0
package/dist/inject-infinite-query.mjs.map +1 -0
package/dist/inject-is-fetching.mjs +31 -0
package/dist/inject-is-fetching.mjs.map +1 -0
package/dist/inject-is-mutating.mjs +31 -0
package/dist/inject-is-mutating.mjs.map +1 -0
package/dist/inject-is-restoring.mjs +24 -0
package/dist/inject-is-restoring.mjs.map +1 -0
package/dist/inject-mutation-state.mjs +51 -0
package/dist/inject-mutation-state.mjs.map +1 -0
package/dist/inject-mutation.mjs +79 -0
package/dist/inject-mutation.mjs.map +1 -0
package/dist/inject-queries.mjs +49 -0
package/dist/inject-queries.mjs.map +1 -0
package/dist/inject-query-client.mjs +9 -0
package/dist/inject-query-client.mjs.map +1 -0
package/dist/inject-query.mjs +14 -0
package/dist/inject-query.mjs.map +1 -0
package/dist/mutation-options.mjs +7 -0
package/dist/mutation-options.mjs.map +1 -0
package/dist/providers.mjs +109 -0
package/dist/providers.mjs.map +1 -0
package/dist/query-options.mjs +7 -0
package/dist/query-options.mjs.map +1 -0
package/dist/signal-proxy.mjs +29 -0
package/dist/signal-proxy.mjs.map +1 -0
package/dist-ts/eslint.config.d.ts +3 -0
package/dist-ts/root.eslint.config.d.ts +3 -0
package/dist-ts/src/__tests__/inject-infinite-query.test-d.d.ts +2 -0
package/dist-ts/src/__tests__/inject-infinite-query.test.d.ts +2 -0
package/dist-ts/src/__tests__/inject-is-fetching.test.d.ts +2 -0
package/dist-ts/src/__tests__/inject-is-mutating.test.d.ts +2 -0
package/dist-ts/src/__tests__/inject-mutation-state.test-d.d.ts +2 -0
package/dist-ts/src/__tests__/inject-mutation-state.test.d.ts +2 -0
package/dist-ts/src/__tests__/inject-mutation.test-d.d.ts +2 -0
package/dist-ts/src/__tests__/inject-mutation.test.d.ts +2 -0
package/dist-ts/src/__tests__/inject-query.test-d.d.ts +2 -0
package/dist-ts/src/__tests__/inject-query.test.d.ts +2 -0
package/dist-ts/src/__tests__/mutation-options.test-d.d.ts +2 -0
package/dist-ts/src/__tests__/provide-query-client.test.d.ts +2 -0
package/dist-ts/src/__tests__/provide-tanstack-query.test.d.ts +2 -0
package/dist-ts/src/__tests__/providers.test.d.ts +2 -0
package/dist-ts/src/__tests__/query-options.test-d.d.ts +2 -0
package/dist-ts/src/__tests__/signal-proxy.test.d.ts +2 -0
package/dist-ts/src/__tests__/test-utils.d.ts +16 -0
package/dist-ts/src/create-base-query.d.ts +9 -0
package/dist-ts/src/index.d.ts +27 -0
package/dist-ts/src/infinite-query-options.d.ts +45 -0
package/dist-ts/src/inject-infinite-query.d.ts +40 -0
package/dist-ts/src/inject-is-fetching.d.ts +23 -0
package/dist-ts/src/inject-is-mutating.d.ts +22 -0
package/{src/inject-is-restoring.ts → dist-ts/src/inject-is-restoring.d.ts} +7 -33
package/dist-ts/src/inject-mutation-state.d.ts +28 -0
package/dist-ts/src/inject-mutation.d.ts +23 -0
package/dist-ts/src/inject-queries.d.ts +78 -0
package/{src/inject-query-client.ts → dist-ts/src/inject-query-client.d.ts} +7 -9
package/{src/inject-query.ts → dist-ts/src/inject-query.d.ts} +14 -117
package/{src/mutation-options.ts → dist-ts/src/mutation-options.d.ts} +5 -26
package/dist-ts/src/providers.d.ts +217 -0
package/dist-ts/src/query-options.d.ts +88 -0
package/dist-ts/src/signal-proxy.d.ts +12 -0
package/dist-ts/src/test-setup.d.ts +2 -0
package/dist-ts/src/types.d.ts +90 -0
package/dist-ts/src/util/is-dev-mode/is-dev-mode.d.ts +2 -0
package/dist-ts/vite.config.d.ts +5 -0
package/package.json +13 -11
package/build/index.d.ts +0 -821
package/build/index.mjs +0 -622
package/build/index.mjs.map +0 -1
package/src/create-base-query.ts +0 -142
package/src/index.ts +0 -64
package/src/infinite-query-options.ts +0 -187
package/src/inject-infinite-query.ts +0 -129
package/src/inject-is-fetching.ts +0 -66
package/src/inject-is-mutating.ts +0 -65
package/src/inject-mutation-state.ts +0 -125
package/src/inject-mutation.ts +0 -169
package/src/inject-queries.ts +0 -271
package/src/providers.ts +0 -368
package/src/query-options.ts +0 -178
package/src/signal-proxy.ts +0 -46
package/src/test-setup.ts +0 -10
package/src/types.ts +0 -309
package/src/util/is-dev-mode/is-dev-mode.ts +0 -3

package/dist-ts/src/inject-queries.d.ts ADDED Viewed

@@ -0,0 +1,78 @@
+import { Injector } from '@angular/core';
+import type { Signal } from '@angular/core';
+import type { 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 {};
+//# sourceMappingURL=inject-queries.d.ts.map

package/{src/inject-query-client.ts → dist-ts/src/inject-query-client.d.ts} RENAMED Viewed

@@ -1,7 +1,6 @@
-import { Injector, inject } from '@angular/core'
-import { QueryClient } from '@tanstack/query-core'
-import type { InjectOptions } from '@angular/core'
+import { Injector } from '@angular/core';
+import { QueryClient } from '@tanstack/query-core';
+import type { InjectOptions } from '@angular/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.
@@ -16,8 +15,7 @@ import type { InjectOptions } from '@angular/core'
  * const queryClient = injectQueryClient();
  * ```
  */
-export function injectQueryClient(
-  injectOptions: InjectOptions & { injector?: Injector } = {},
-) {
-  return (injectOptions.injector ?? inject(Injector)).get(QueryClient)
-}
+export declare function injectQueryClient(injectOptions?: InjectOptions & {
+    injector?: Injector;
+}): QueryClient;
+//# sourceMappingURL=inject-query-client.d.ts.map

package/{src/inject-query.ts → dist-ts/src/inject-query.d.ts} RENAMED Viewed

@@ -1,31 +1,15 @@
-import { QueryObserver } from '@tanstack/query-core'
-import {
-  Injector,
-  assertInInjectionContext,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-import { createBaseQuery } from './create-base-query'
-import type { DefaultError, QueryKey } from '@tanstack/query-core'
-import type {
-  CreateQueryOptions,
-  CreateQueryResult,
-  DefinedCreateQueryResult,
-} from './types'
-import type {
-  DefinedInitialDataOptions,
-  UndefinedInitialDataOptions,
-} from './query-options'
+import { Injector } from '@angular/core';
+import type { DefaultError, QueryKey } from '@tanstack/query-core';
+import type { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types';
+import type { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-options';
 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
+    /**
+     * 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.
  *
@@ -63,21 +47,7 @@ export interface InjectQueryOptions {
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  injectQueryFn: () => DefinedInitialDataOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  >,
-  options?: InjectQueryOptions,
-): DefinedCreateQueryResult<TData, TError>
+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.
  *
@@ -115,21 +85,7 @@ export function injectQuery<
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  injectQueryFn: () => UndefinedInitialDataOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  >,
-  options?: InjectQueryOptions,
-): CreateQueryResult<TData, TError>
+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.
  *
@@ -167,64 +123,5 @@ export function injectQuery<
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  injectQueryFn: () => CreateQueryOptions<
-    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 function injectQuery(
-  injectQueryFn: () => CreateQueryOptions,
-  options?: InjectQueryOptions,
-) {
-  !options?.injector && assertInInjectionContext(injectQuery)
-  return runInInjectionContext(options?.injector ?? inject(Injector), () =>
-    createBaseQuery(injectQueryFn, QueryObserver),
-  ) as unknown as CreateQueryResult
-}
+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>;
+//# sourceMappingURL=inject-query.d.ts.map

package/{src/mutation-options.ts → dist-ts/src/mutation-options.d.ts} RENAMED Viewed

@@ -1,9 +1,4 @@
-import type {
-  DefaultError,
-  MutationObserverOptions,
-  OmitKeyof,
-} from '@tanstack/query-core'
+import type { DefaultError, MutationObserverOptions, OmitKeyof } from '@tanstack/query-core';
 /**
  * Allows to share and re-use mutation options in a type-safe way.
  *
@@ -35,26 +30,10 @@ import type {
  * @returns Mutation options.
  * @public
  */
-export function mutationOptions<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
->(
-  options: MutationObserverOptions<TData, TError, TVariables, TContext>,
-): CreateMutationOptions<TData, TError, TVariables, TContext> {
-  return options
-}
+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'
-  > {}
+export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
+}
+//# sourceMappingURL=mutation-options.d.ts.map

package/dist-ts/src/providers.d.ts ADDED Viewed

@@ -0,0 +1,217 @@
+import { InjectionToken } from '@angular/core';
+import { QueryClient } from '@tanstack/query-core';
+import type { Provider } from '@angular/core';
+import type { DevtoolsButtonPosition, DevtoolsErrorType, DevtoolsPosition } from '@tanstack/query-devtools';
+/**
+ * Usually {@link provideTanStackQuery} is used once to set up TanStack Query and the
+ * {@link https://tanstack.com/query/latest/docs/reference/QueryClient|QueryClient}
+ * for the entire application. Internally it calls `provideQueryClient`.
+ * You can use `provideQueryClient` to provide a different `QueryClient` instance for a part
+ * of the application or for unit testing purposes.
+ * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
+ * @returns a provider object that can be used to provide the `QueryClient` instance.
+ */
+export declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
+/**
+ * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
+ *
+ * Allows to configure a `QueryClient` and optional features such as developer tools.
+ *
+ * **Example - standalone**
+ *
+ * ```ts
+ * import {
+ *   provideTanStackQuery,
+ *   QueryClient,
+ * } from '@tanstack/angular-query-experimental'
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideTanStackQuery(new QueryClient())],
+ * })
+ * ```
+ *
+ * **Example - NgModule-based**
+ *
+ * ```ts
+ * import {
+ *   provideTanStackQuery,
+ *   QueryClient,
+ * } from '@tanstack/angular-query-experimental'
+ *
+ * @NgModule({
+ *   declarations: [AppComponent],
+ *   imports: [BrowserModule],
+ *   providers: [provideTanStackQuery(new QueryClient())],
+ *   bootstrap: [AppComponent],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * You can also enable optional developer tools by adding `withDevtools`. By
+ * default the tools will then be loaded when your app is in development mode.
+ * ```ts
+ * import {
+ *   provideTanStackQuery,
+ *   withDevtools
+ *   QueryClient,
+ * } from '@tanstack/angular-query-experimental'
+ *
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideTanStackQuery(new QueryClient(), withDevtools())
+ *     ]
+ *   }
+ * )
+ * ```
+ *
+ * **Example: using an InjectionToken**
+ *
+ * ```ts
+ * export const MY_QUERY_CLIENT = new InjectionToken('', {
+ *   factory: () => new QueryClient(),
+ * })
+ *
+ * // In a lazy loaded route or lazy loaded component's providers array:
+ * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
+ * ```
+ * @param queryClient - A `QueryClient` instance, or an `InjectionToken` which provides a `QueryClient`.
+ * @param features - Optional features to configure additional Query functionality.
+ * @returns A set of providers to set up TanStack Query.
+ * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
+ * @see withDevtools
+ */
+export declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
+/**
+ * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
+ *
+ * Allows to configure a `QueryClient`.
+ * @param queryClient - A `QueryClient` instance.
+ * @returns A set of providers to set up TanStack Query.
+ * @public
+ * @see https://tanstack.com/query/v5/docs/framework/angular/quick-start
+ * @deprecated Use `provideTanStackQuery` instead.
+ */
+export declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
+/**
+ * Helper type to represent a Query feature.
+ */
+export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
+    ɵkind: TFeatureKind;
+    ɵproviders: Array<Provider>;
+}
+/**
+ * Helper function to create an object that represents a Query feature.
+ * @param kind -
+ * @param providers -
+ * @returns A Query feature.
+ */
+export declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;
+/**
+ * A type alias that represents a feature which enables developer tools.
+ * The type is used to describe the return value of the `withDevtools` function.
+ * @public
+ * @see {@link withDevtools}
+ */
+export type DeveloperToolsFeature = QueryFeature<'DeveloperTools'>;
+/**
+ * A type alias that represents a feature which enables persistence.
+ * The type is used to describe the return value of the `withPersistQueryClient` function.
+ * @public
+ */
+export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
+/**
+ * Options for configuring the TanStack Query devtools.
+ * @public
+ */
+export interface DevtoolsOptions {
+    /**
+     * Set this true if you want the devtools to default to being open
+     */
+    initialIsOpen?: boolean;
+    /**
+     * The position of the TanStack logo to open and close the devtools panel.
+     * `top-left` | `top-right` | `bottom-left` | `bottom-right` | `relative`
+     * Defaults to `bottom-right`.
+     */
+    buttonPosition?: DevtoolsButtonPosition;
+    /**
+     * The position of the TanStack Query devtools panel.
+     * `top` | `bottom` | `left` | `right`
+     * Defaults to `bottom`.
+     */
+    position?: DevtoolsPosition;
+    /**
+     * Custom instance of QueryClient
+     */
+    client?: QueryClient;
+    /**
+     * Use this so you can define custom errors that can be shown in the devtools.
+     */
+    errorTypes?: Array<DevtoolsErrorType>;
+    /**
+     * Use this to pass a nonce to the style tag that is added to the document head. This is useful if you are using a Content Security Policy (CSP) nonce to allow inline styles.
+     */
+    styleNonce?: string;
+    /**
+     * Use this so you can attach the devtool's styles to a specific element in the DOM.
+     */
+    shadowDOMTarget?: ShadowRoot;
+    /**
+     * Whether the developer tools should load.
+     * - `auto`- (Default) Lazily loads devtools when in development mode. Skips loading in production mode.
+     * - `true`- Always load the devtools, regardless of the environment.
+     * - `false`- Never load the devtools, regardless of the environment.
+     *
+     * You can use `true` and `false` to override loading developer tools from an environment file.
+     * For example, a test environment might run in production mode but you may want to load developer tools.
+     *
+     * Additionally, you can use a signal in the callback to dynamically load the devtools based on a condition. For example,
+     * a signal created from a RxJS observable that listens for a keyboard shortcut.
+     *
+     * **Example**
+     * ```ts
+     *    withDevtools(() => ({
+     *      initialIsOpen: true,
+     *      loadDevtools: inject(ExampleService).loadDevtools()
+     *    }))
+     *  ```
+     */
+    loadDevtools?: 'auto' | boolean;
+}
+/**
+ * Enables developer tools.
+ *
+ * **Example**
+ *
+ * ```ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideTanStackQuery(new QueryClient(), withDevtools())
+ *   ]
+ * }
+ * ```
+ * By default the devtools will be loaded when Angular runs in development mode and rendered in `<body>`.
+ *
+ * If you need more control over when devtools are loaded, you can use the `loadDevtools` option. This is particularly useful if you want to load devtools based on environment configurations. For instance, you might have a test environment running in production mode but still require devtools to be available.
+ *
+ * If you need more control over where devtools are rendered, consider `injectDevtoolsPanel`. This allows rendering devtools inside your own devtools for example.
+ * @param withDevtoolsFn - A function that returns `DevtoolsOptions`.
+ * @returns A set of providers for use with `provideTanStackQuery`.
+ * @public
+ * @see {@link provideTanStackQuery}
+ * @see {@link DevtoolsOptions}
+ */
+export declare function withDevtools(withDevtoolsFn?: () => DevtoolsOptions): DeveloperToolsFeature;
+/**
+ * A type alias that represents all Query features available for use with `provideTanStackQuery`.
+ * Features can be enabled by adding special functions to the `provideTanStackQuery` call.
+ * See documentation for each symbol to find corresponding function name. See also `provideTanStackQuery`
+ * documentation on how to use those functions.
+ * @public
+ * @see {@link provideTanStackQuery}
+ */
+export type QueryFeatures = DeveloperToolsFeature | PersistQueryClientFeature;
+export declare const queryFeatures: readonly ["DeveloperTools", "PersistQueryClient"];
+export type QueryFeatureKind = (typeof queryFeatures)[number];
+//# sourceMappingURL=providers.d.ts.map

package/dist-ts/src/query-options.d.ts ADDED Viewed

@@ -0,0 +1,88 @@
+import type { DataTag, DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, SkipToken } from '@tanstack/query-core';
+import type { CreateQueryOptions } from './types';
+export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
+};
+export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
+    queryFn?: Exclude<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken | undefined>;
+};
+export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
+    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+    queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
+};
+/**
+ * Allows to share and re-use query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ *
+ * **Example**
+ *
+ * ```ts
+ *  const { queryKey } = queryOptions({
+ *     queryKey: ['key'],
+ *     queryFn: () => Promise.resolve(5),
+ *     //  ^?  Promise<number>
+ *   })
+ *
+ *   const queryClient = new QueryClient()
+ *   const data = queryClient.getQueryData(queryKey)
+ *   //    ^?  number | undefined
+ * ```
+ * @param options - The query options to tag with the type from `queryFn`.
+ * @returns The tagged query options.
+ * @public
+ */
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+/**
+ * Allows to share and re-use query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ *
+ * **Example**
+ *
+ * ```ts
+ *  const { queryKey } = queryOptions({
+ *     queryKey: ['key'],
+ *     queryFn: () => Promise.resolve(5),
+ *     //  ^?  Promise<number>
+ *   })
+ *
+ *   const queryClient = new QueryClient()
+ *   const data = queryClient.getQueryData(queryKey)
+ *   //    ^?  number | undefined
+ * ```
+ * @param options - The query options to tag with the type from `queryFn`.
+ * @returns The tagged query options.
+ * @public
+ */
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+/**
+ * Allows to share and re-use query options in a type-safe way.
+ *
+ * The `queryKey` will be tagged with the type from `queryFn`.
+ *
+ * **Example**
+ *
+ * ```ts
+ *  const { queryKey } = queryOptions({
+ *     queryKey: ['key'],
+ *     queryFn: () => Promise.resolve(5),
+ *     //  ^?  Promise<number>
+ *   })
+ *
+ *   const queryClient = new QueryClient()
+ *   const data = queryClient.getQueryData(queryKey)
+ *   //    ^?  number | undefined
+ * ```
+ * @param options - The query options to tag with the type from `queryFn`.
+ * @returns The tagged query options.
+ * @public
+ */
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+//# sourceMappingURL=query-options.d.ts.map

package/dist-ts/src/signal-proxy.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import type { Signal } from '@angular/core';
+export type MapToSignals<T> = {
+    [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>;
+};
+/**
+ * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
+ * Functions on the object are passed through as-is.
+ * @param inputSignal - `Signal` that must return an object.
+ * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
+ */
+export declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;
+//# sourceMappingURL=signal-proxy.d.ts.map

package/dist-ts/src/test-setup.d.ts ADDED Viewed

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