@octanejs/tanstack-query 0.1.2

package/src/useBaseQuery.ts

@@ -0,0 +1,153 @@
+// `useBaseQuery` — the shared core of `useQuery` (and friends), reimplemented on
+// octane's hooks. Mirrors @tanstack/react-query's useBaseQuery: it creates a
+// query Observer, subscribes to it via useSyncExternalStore, and pushes option
+// changes through useEffect. The single compiler-injected slot is split into
+// distinct sub-slots for each internal base hook, the same way the zustand
+// `traditional` binding does.
+import { useState, useCallback, useSyncExternalStore, useEffect, use } from 'octane';
+import { environmentManager, noop, notifyManager } from '@tanstack/query-core';
+import { resolveClient } from './context';
+import { useIsRestoring } from './isRestoring';
+import { useQueryErrorResetBoundary } from './errorResetBoundary';
+import {
+	ensurePreventErrorBoundaryRetry,
+	ensureSuspenseTimers,
+	fetchOptimistic,
+	getHasError,
+	shouldSuspend,
+	subSlot,
+	willFetch,
+} from './internal';
+
+export function useBaseQuery(
+	options: any,
+	Observer: any,
+	queryClient: any,
+	slot: symbol | undefined,
+): any {
+	if (process.env.NODE_ENV !== 'production') {
+		if (typeof options !== 'object' || Array.isArray(options)) {
+			throw new Error(
+				'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object',
+			);
+		}
+	}
+
+	const oq = (tag: string) => subSlot(slot, 'oq:' + tag);
+	const client = resolveClient(queryClient);
+	const isRestoring = useIsRestoring();
+	const errorResetBoundary = useQueryErrorResetBoundary();
+	const defaultedOptions = client.defaultQueryOptions(options);
+
+	(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(defaultedOptions);
+
+	const query = client.getQueryCache().get(defaultedOptions.queryHash);
+
+	if (process.env.NODE_ENV !== 'production') {
+		if (!defaultedOptions.queryFn) {
+			console.error(
+				`[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`,
+			);
+		}
+	}
+
+	// `subscribed: false` makes a passive query (read the cache, never subscribe).
+	// While restoring a persisted client, queries also stay passive.
+	const subscribed = options.subscribed !== false;
+	defaultedOptions._optimisticResults = isRestoring
+		? 'isRestoring'
+		: subscribed
+			? 'optimistic'
+			: undefined;
+
+	ensureSuspenseTimers(defaultedOptions);
+	ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
+	// Clear the reset boundary on mount (so a fresh mount can throw again).
+	useEffect(
+		() => {
+			errorResetBoundary.clearReset();
+		},
+		[errorResetBoundary],
+		oq('clr'),
+	);
+
+	// Probed BEFORE creating the Observer — the constructor can create the entry.
+	const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+
+	const [observer] = useState(() => new Observer(client, defaultedOptions), oq('obs'));
+
+	const result = observer.getOptimisticResult(defaultedOptions);
+
+	const shouldSubscribe = !isRestoring && subscribed;
+	useSyncExternalStore(
+		useCallback(
+			(onStoreChange: () => void) => {
+				const unsubscribe = shouldSubscribe
+					? observer.subscribe(notifyManager.batchCalls(onStoreChange))
+					: noop;
+				observer.updateResult();
+				return unsubscribe;
+			},
+			[observer, shouldSubscribe],
+			oq('cb'),
+		),
+		() => observer.getCurrentResult(),
+		() => observer.getCurrentResult(),
+		oq('uses'),
+	);
+
+	useEffect(
+		() => {
+			observer.setOptions(defaultedOptions);
+		},
+		[defaultedOptions, observer],
+		oq('eff'),
+	);
+
+	// Suspense: suspend on the in-flight promise via `use(thenable)` (octane's
+	// suspend primitive — NOT a raw `throw promise`). fetchOptimistic clears the
+	// reset boundary on error (upstream suspense.ts), so a reset→retry that fails
+	// again re-throws to the boundary on replay instead of falling through with
+	// undefined data. The promise resolves even on error; the replay surfaces the
+	// error through the error-boundary throw below.
+	if (shouldSuspend(defaultedOptions, result)) {
+		use(fetchOptimistic(defaultedOptions, observer, errorResetBoundary));
+	}
+
+	// Error boundary: throw so the nearest @try/@catch (or <ErrorBoundary>) handles
+	// it, when the query errored and the options opt into throwing.
+	if (
+		getHasError({
+			result,
+			errorResetBoundary,
+			throwOnError: defaultedOptions.throwOnError,
+			query,
+			suspense: defaultedOptions.suspense,
+		})
+	) {
+		throw result.error;
+	}
+
+	(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(defaultedOptions, result);
+
+	// experimental_prefetchInRender: kick the fetch during render so
+	// `result.promise` settles even if the component unmounts, and finalize the
+	// observer's thenable (via updateResult) when the data lands.
+	if (
+		defaultedOptions.experimental_prefetchInRender &&
+		!environmentManager.isServer() &&
+		willFetch(result, isRestoring)
+	) {
+		const promise = isNewCacheEntry
+			? // Fetch immediately on render so `.promise` resolves even on unmount.
+				fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+			: // Subscribe to the cache promise to finalize the current thenable.
+				query?.promise;
+
+		promise?.catch(noop).finally(() => {
+			observer.updateResult();
+		});
+	}
+
+	return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}

package/src/useInfiniteQuery.ts

@@ -0,0 +1,52 @@
+import { InfiniteQueryObserver } from '@tanstack/query-core';
+import type { DefaultError, InfiniteData, QueryClient, QueryKey } from '@tanstack/query-core';
+import { useBaseQuery } from './useBaseQuery';
+import { splitSlot } from './internal';
+import type {
+	DefinedUseInfiniteQueryResult,
+	UseInfiniteQueryOptions,
+	UseInfiniteQueryResult,
+} from './types';
+import type {
+	DefinedInitialDataInfiniteOptions,
+	UndefinedInitialDataInfiniteOptions,
+} from './infiniteQueryOptions';
+
+// Overloads match @tanstack/react-query's useInfiniteQuery.ts.
+export function useInfiniteQuery<
+	TQueryFnData,
+	TError = DefaultError,
+	TData = InfiniteData<TQueryFnData>,
+	TQueryKey extends QueryKey = QueryKey,
+	TPageParam = unknown,
+>(
+	options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
+	queryClient?: QueryClient,
+): DefinedUseInfiniteQueryResult<TData, TError>;
+
+export function useInfiniteQuery<
+	TQueryFnData,
+	TError = DefaultError,
+	TData = InfiniteData<TQueryFnData>,
+	TQueryKey extends QueryKey = QueryKey,
+	TPageParam = unknown,
+>(
+	options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
+	queryClient?: QueryClient,
+): UseInfiniteQueryResult<TData, TError>;
+
+export function useInfiniteQuery<
+	TQueryFnData,
+	TError = DefaultError,
+	TData = InfiniteData<TQueryFnData>,
+	TQueryKey extends QueryKey = QueryKey,
+	TPageParam = unknown,
+>(
+	options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
+	queryClient?: QueryClient,
+): UseInfiniteQueryResult<TData, TError>;
+
+export function useInfiniteQuery(options: any, ...rest: any[]): any {
+	const [user, slot] = splitSlot(rest);
+	return useBaseQuery(options, InfiniteQueryObserver, user[0], slot);
+}

package/src/useIsFetching.ts

@@ -0,0 +1,25 @@
+import { notifyManager } from '@tanstack/query-core';
+import type { QueryClient, QueryFilters } from '@tanstack/query-core';
+import { useSyncExternalStore, useCallback } from 'octane';
+import { resolveClient } from './context';
+import { splitSlot, subSlot } from './internal';
+
+// Signature matches @tanstack/react-query's useIsFetching.ts.
+export function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
+
+export function useIsFetching(...args: any[]): number {
+	const [user, slot] = splitSlot(args);
+	const filters = user[0];
+	const client = resolveClient(user[1]);
+	const queryCache = client.getQueryCache();
+	return useSyncExternalStore(
+		useCallback(
+			(onStoreChange: () => void) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),
+			[queryCache],
+			subSlot(slot, 'if:cb'),
+		),
+		() => client.isFetching(filters),
+		() => client.isFetching(filters),
+		subSlot(slot, 'if:uses'),
+	);
+}

package/src/useMutation.ts

@@ -0,0 +1,65 @@
+// `useMutation` — reimplemented on octane's hooks, mirroring
+// @tanstack/react-query: a MutationObserver subscribed via useSyncExternalStore,
+// with a stable `mutate` callback. The single compiler-injected slot is split
+// into distinct sub-slots for each internal base hook.
+import { useState, useCallback, useSyncExternalStore, useEffect } from 'octane';
+import { MutationObserver, noop, notifyManager, shouldThrowError } from '@tanstack/query-core';
+import type { DefaultError, QueryClient } from '@tanstack/query-core';
+import { resolveClient } from './context';
+import { splitSlot, subSlot as subSlotBase } from './internal';
+import type { UseMutationOptions, UseMutationResult } from './types';
+
+// Namespaced per-hook (':om:') on top of the shared helper — the minted symbols
+// are byte-identical to the previous private copy, so slot identity is stable.
+const subSlot = (slot: symbol | undefined, tag: string) => subSlotBase(slot, 'om:' + tag);
+
+// Signature matches @tanstack/react-query's useMutation.ts.
+export function useMutation<
+	TData = unknown,
+	TError = DefaultError,
+	TVariables = void,
+	TOnMutateResult = unknown,
+>(
+	options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+	queryClient?: QueryClient,
+): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
+
+export function useMutation(options: any, ...rest: any[]): any {
+	const [user, slot] = splitSlot(rest);
+	const client = resolveClient(user[0]);
+
+	const [observer] = useState(() => new MutationObserver(client, options), subSlot(slot, 'obs'));
+
+	useEffect(
+		() => {
+			observer.setOptions(options);
+		},
+		[observer, options],
+		subSlot(slot, 'eff'),
+	);
+
+	const result = useSyncExternalStore(
+		useCallback(
+			(onStoreChange: () => void) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
+			[observer],
+			subSlot(slot, 'cb'),
+		),
+		() => observer.getCurrentResult(),
+		() => observer.getCurrentResult(),
+		subSlot(slot, 'uses'),
+	);
+
+	const mutate = useCallback(
+		(variables: any, mutateOptions: any) => {
+			observer.mutate(variables, mutateOptions).catch(noop);
+		},
+		[observer],
+		subSlot(slot, 'mut'),
+	);
+
+	if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) {
+		throw result.error;
+	}
+
+	return { ...result, mutate, mutateAsync: result.mutate };
+}

package/src/useMutationState.ts

@@ -0,0 +1,78 @@
+import { notifyManager, replaceEqualDeep } from '@tanstack/query-core';
+import type { Mutation, MutationFilters, MutationState, QueryClient } from '@tanstack/query-core';
+import { useSyncExternalStore, useCallback, useRef, useEffect } from 'octane';
+import { resolveClient } from './context';
+import { splitSlot, subSlot } from './internal';
+
+// Per upstream useMutationState.ts (kept module-private there too).
+type MutationStateOptions<TResult = MutationState> = {
+	filters?: MutationFilters;
+	select?: (mutation: Mutation) => TResult;
+};
+
+function getResult(mutationCache: any, options: any): any[] {
+	return mutationCache
+		.findAll(options.filters)
+		.map((mutation: any) => (options.select ? options.select(mutation) : mutation.state));
+}
+
+// Signatures match @tanstack/react-query's useMutationState.ts.
+export function useMutationState<TResult = MutationState>(
+	options?: MutationStateOptions<TResult>,
+	queryClient?: QueryClient,
+): Array<TResult>;
+
+export function useMutationState(...args: any[]): any[] {
+	const [user, slot] = splitSlot(args);
+	const options = user[0] ?? {};
+	const mutationCache = resolveClient(user[1]).getMutationCache();
+
+	const optionsRef = useRef(options, subSlot(slot, 'ms:opt'));
+	const result = useRef<any[] | null>(null, subSlot(slot, 'ms:res'));
+	if (result.current === null) {
+		result.current = getResult(mutationCache, options);
+	}
+	useEffect(
+		() => {
+			optionsRef.current = options;
+		},
+		undefined,
+		subSlot(slot, 'ms:eff'),
+	);
+
+	return useSyncExternalStore(
+		useCallback(
+			(onStoreChange: () => void) =>
+				mutationCache.subscribe(() => {
+					const next = replaceEqualDeep(
+						result.current,
+						getResult(mutationCache, optionsRef.current),
+					);
+					if (result.current !== next) {
+						result.current = next;
+						notifyManager.schedule(onStoreChange);
+					}
+				}),
+			[mutationCache],
+			subSlot(slot, 'ms:cb'),
+		),
+		() => result.current as any[],
+		() => result.current as any[],
+		subSlot(slot, 'ms:uses'),
+	);
+}
+
+// Signature matches @tanstack/react-query's useMutationState.ts.
+export function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
+
+export function useIsMutating(...args: any[]): number {
+	const [user, slot] = splitSlot(args);
+	const filters = user[0];
+	const client = resolveClient(user[1]);
+	// Forward this hook's slot to useMutationState (it owns the base hooks).
+	return (useMutationState as (...a: any[]) => any[])(
+		{ filters: { ...filters, status: 'pending' } },
+		client,
+		slot,
+	).length;
+}

package/src/usePrefetch.ts

@@ -0,0 +1,48 @@
+import type {
+	DefaultError,
+	FetchInfiniteQueryOptions,
+	QueryClient,
+	QueryKey,
+} from '@tanstack/query-core';
+import { resolveClient } from './context';
+import { splitSlot } from './internal';
+import type { UsePrefetchQueryOptions } from './types';
+
+// Signatures match @tanstack/react-query's usePrefetchQuery.tsx /
+// usePrefetchInfiniteQuery.tsx.
+export function usePrefetchQuery<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+>(
+	options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+	queryClient?: QueryClient,
+): void;
+
+export function usePrefetchQuery(options: any, ...rest: any[]): void {
+	const [user] = splitSlot(rest);
+	const client = resolveClient(user[0]);
+	if (!client.getQueryState(options.queryKey)) {
+		client.prefetchQuery(options);
+	}
+}
+
+export function usePrefetchInfiniteQuery<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+	TPageParam = unknown,
+>(
+	options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
+	queryClient?: QueryClient,
+): void;
+
+export function usePrefetchInfiniteQuery(options: any, ...rest: any[]): void {
+	const [user] = splitSlot(rest);
+	const client = resolveClient(user[0]);
+	if (!client.getQueryState(options.queryKey)) {
+		client.prefetchInfiniteQuery(options);
+	}
+}

package/src/useQueries.ts

@@ -0,0 +1,134 @@
+import { QueriesObserver, QueryObserver, noop, notifyManager } from '@tanstack/query-core';
+import type { QueryClient } from '@tanstack/query-core';
+import { useState, useMemo, useSyncExternalStore, useCallback, useEffect, use } from 'octane';
+import { resolveClient } from './context';
+import { useIsRestoring } from './isRestoring';
+import { useQueryErrorResetBoundary } from './errorResetBoundary';
+import {
+	ensurePreventErrorBoundaryRetry,
+	ensureSuspenseTimers,
+	fetchOptimistic,
+	getHasError,
+	shouldSuspend,
+	splitSlot,
+	subSlot,
+} from './internal';
+import type { QueriesOptions, QueriesResults } from './queries-types';
+
+// Signature matches @tanstack/react-query's useQueries.ts — per-entry tuple
+// inference via QueriesOptions/QueriesResults, with `combine` re-typing the
+// aggregate result. The untyped implementation signature also accepts the
+// compiler-injected trailing slot symbol.
+export function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(
+	options: {
+		queries: readonly [...QueriesOptions<T>];
+		combine?: (result: QueriesResults<T>) => TCombinedResult;
+		subscribed?: boolean;
+	},
+	queryClient?: QueryClient,
+): TCombinedResult;
+
+export function useQueries(options: any, ...rest: any[]): any {
+	const [user, slot] = splitSlot(rest);
+	const client = resolveClient(user[0]);
+	const isRestoring = useIsRestoring();
+	const errorResetBoundary = useQueryErrorResetBoundary();
+	const { queries, ...restOptions } = options;
+	const qs = (tag: string) => subSlot(slot, 'qs:' + tag);
+
+	const defaultedQueries = useMemo(
+		() =>
+			queries.map((opts: any) => {
+				const defaulted = client.defaultQueryOptions(opts);
+				defaulted._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
+				return defaulted;
+			}),
+		[queries, client, isRestoring],
+		qs('memo'),
+	);
+	defaultedQueries.forEach((queryOptions: any) => {
+		ensureSuspenseTimers(queryOptions);
+		ensurePreventErrorBoundaryRetry(
+			queryOptions,
+			errorResetBoundary,
+			client.getQueryCache().get(queryOptions.queryHash),
+		);
+	});
+	useEffect(
+		() => {
+			errorResetBoundary.clearReset();
+		},
+		[errorResetBoundary],
+		qs('clr'),
+	);
+
+	const [observer] = useState(
+		() => new QueriesObserver(client, defaultedQueries, restOptions),
+		qs('obs'),
+	);
+
+	const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
+		defaultedQueries,
+		restOptions.combine,
+	);
+
+	const shouldSubscribe = !isRestoring && restOptions.subscribed !== false;
+	useSyncExternalStore(
+		useCallback(
+			(onStoreChange: () => void) =>
+				shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop,
+			[observer, shouldSubscribe],
+			qs('cb'),
+		),
+		() => observer.getCurrentResult(),
+		() => observer.getCurrentResult(),
+		qs('uses'),
+	);
+
+	useEffect(
+		() => {
+			observer.setQueries(defaultedQueries, restOptions);
+		},
+		[defaultedQueries, restOptions, observer],
+		qs('eff'),
+	);
+
+	// Suspense: if any query should suspend, suspend on Promise.all of their
+	// optimistic fetches. octane suspends via use(thenable), not `throw promise`.
+	const shouldAtLeastOneSuspend = optimisticResult.some((result: any, index: number) =>
+		shouldSuspend(defaultedQueries[index], result),
+	);
+	if (shouldAtLeastOneSuspend) {
+		const suspensePromises = optimisticResult.flatMap((result: any, index: number) => {
+			const opts = defaultedQueries[index];
+			if (opts && shouldSuspend(opts, result)) {
+				// fetchOptimistic clears the reset boundary on error (upstream
+				// suspense.ts) so a reset→retry→fail-again re-throws to the boundary.
+				return fetchOptimistic(opts, new QueryObserver(client, opts), errorResetBoundary);
+			}
+			return [];
+		});
+		if (suspensePromises.length > 0) {
+			use(Promise.all(suspensePromises));
+		}
+	}
+
+	const firstError = optimisticResult.find((result: any, index: number) => {
+		const query = defaultedQueries[index];
+		return (
+			query &&
+			getHasError({
+				result,
+				errorResetBoundary,
+				throwOnError: query.throwOnError,
+				query: client.getQueryCache().get(query.queryHash),
+				suspense: query.suspense,
+			})
+		);
+	});
+	if (firstError?.error) {
+		throw firstError.error;
+	}
+
+	return getCombinedResult(trackResult());
+}

package/src/useQuery.ts

@@ -0,0 +1,47 @@
+import { QueryObserver } from '@tanstack/query-core';
+import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core';
+import { useBaseQuery } from './useBaseQuery';
+import type { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
+import type { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './queryOptions';
+
+// Overloads match @tanstack/react-query's useQuery.ts: `initialData` narrows the
+// result to DefinedUseQueryResult. The untyped implementation signature also
+// accepts the compiler-injected trailing slot symbol (never visible to users).
+export function useQuery<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+>(
+	options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+	queryClient?: QueryClient,
+): DefinedUseQueryResult<NoInfer<TData>, TError>;
+
+export function useQuery<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+>(
+	options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+	queryClient?: QueryClient,
+): UseQueryResult<NoInfer<TData>, TError>;
+
+export function useQuery<
+	TQueryFnData = unknown,
+	TError = DefaultError,
+	TData = TQueryFnData,
+	TQueryKey extends QueryKey = QueryKey,
+>(
+	options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+	queryClient?: QueryClient,
+): UseQueryResult<NoInfer<TData>, TError>;
+
+export function useQuery(options: any, ...rest: any[]): any {
+	// `[queryClient?, slot?]` — the slot (symbol) is the compiler-injected trailing
+	// arg; an explicit client is the first non-symbol arg.
+	const tail = rest[rest.length - 1];
+	const slot = typeof tail === 'symbol' ? (tail as symbol) : undefined;
+	const queryClient = typeof rest[0] !== 'symbol' ? rest[0] : undefined;
+	return useBaseQuery(options, QueryObserver, queryClient, slot);
+}

package/src/useSuspenseQueries.ts

@@ -0,0 +1,38 @@
+import { skipToken } from '@tanstack/query-core';
+import type { QueryClient } from '@tanstack/query-core';
+import { defaultThrowOnError } from './internal';
+import { useQueries } from './useQueries';
+import type { SuspenseQueriesOptions, SuspenseQueriesResults } from './suspense-queries-types';
+
+// Signature matches @tanstack/react-query's useSuspenseQueries.ts.
+export function useSuspenseQueries<
+	T extends Array<any>,
+	TCombinedResult = SuspenseQueriesResults<T>,
+>(
+	options: {
+		queries: readonly [...SuspenseQueriesOptions<T>];
+		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
+	},
+	queryClient?: QueryClient,
+): TCombinedResult;
+
+export function useSuspenseQueries(options: any, ...rest: any[]): any {
+	return useQueries(
+		{
+			...options,
+			queries: options.queries.map((query: any) => {
+				if (process.env.NODE_ENV !== 'production' && query.queryFn === skipToken) {
+					console.error('skipToken is not allowed for useSuspenseQueries');
+				}
+				return {
+					...query,
+					suspense: true,
+					throwOnError: defaultThrowOnError,
+					enabled: true,
+					placeholderData: undefined,
+				};
+			}),
+		},
+		...rest,
+	);
+}