@tanstack/react-query 5.101.4 → 5.102.0

package/build/legacy/useQueries.cjs

@@ -1,128 +1,70 @@
-"use strict";
 "use client";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/useQueries.ts
-var useQueries_exports = {};
-__export(useQueries_exports, {
-  useQueries: () => useQueries
-});
-module.exports = __toCommonJS(useQueries_exports);
-var React = __toESM(require("react"), 1);
-var import_query_core = require("@tanstack/query-core");
-var import_QueryClientProvider = require("./QueryClientProvider.cjs");
-var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
-var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
-var import_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
-var import_suspense = require("./suspense.cjs");
-function useQueries({
-  queries,
-  ...options
-}, queryClient) {
-  const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
-  const isRestoring = (0, import_IsRestoringProvider.useIsRestoring)();
-  const errorResetBoundary = (0, import_QueryErrorResetBoundary.useQueryErrorResetBoundary)();
-  const defaultedQueries = React.useMemo(
-    () => queries.map((opts) => {
-      const defaultedOptions = client.defaultQueryOptions(
-        opts
-      );
-      defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
-      return defaultedOptions;
-    }),
-    [queries, client, isRestoring]
-  );
-  defaultedQueries.forEach((queryOptions) => {
-    (0, import_suspense.ensureSuspenseTimers)(queryOptions);
-    const query = client.getQueryCache().get(queryOptions.queryHash);
-    (0, import_errorBoundaryUtils.ensurePreventErrorBoundaryRetry)(queryOptions, errorResetBoundary, query);
-  });
-  (0, import_errorBoundaryUtils.useClearResetErrorBoundary)(errorResetBoundary);
-  const [observer] = React.useState(
-    () => new import_query_core.QueriesObserver(
-      client,
-      defaultedQueries,
-      options
-    )
-  );
-  const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
-    defaultedQueries,
-    options.combine
-  );
-  const shouldSubscribe = !isRestoring && options.subscribed !== false;
-  React.useSyncExternalStore(
-    React.useCallback(
-      (onStoreChange) => shouldSubscribe ? observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)) : import_query_core.noop,
-      [observer, shouldSubscribe]
-    ),
-    () => observer.getCurrentResult(),
-    () => observer.getCurrentResult()
-  );
-  React.useEffect(() => {
-    observer.setQueries(
-      defaultedQueries,
-      options
-    );
-  }, [defaultedQueries, options, observer]);
-  const shouldAtLeastOneSuspend = optimisticResult.some(
-    (result, index) => (0, import_suspense.shouldSuspend)(defaultedQueries[index], result)
-  );
-  const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
-    const opts = defaultedQueries[index];
-    if (opts && (0, import_suspense.shouldSuspend)(opts, result)) {
-      const queryObserver = new import_query_core.QueryObserver(client, opts);
-      return (0, import_suspense.fetchOptimistic)(opts, queryObserver, errorResetBoundary);
-    }
-    return [];
-  }) : [];
-  if (suspensePromises.length > 0) {
-    throw Promise.all(suspensePromises);
-  }
-  const firstSingleResultWhichShouldThrow = optimisticResult.find(
-    (result, index) => {
-      const query = defaultedQueries[index];
-      return query && (0, import_errorBoundaryUtils.getHasError)({
-        result,
-        errorResetBoundary,
-        throwOnError: query.throwOnError,
-        query: client.getQueryCache().get(query.queryHash),
-        suspense: query.suspense
-      });
-    }
-  );
-  if (firstSingleResultWhichShouldThrow == null ? void 0 : firstSingleResultWhichShouldThrow.error) {
-    throw firstSingleResultWhichShouldThrow.error;
-  }
-  return getCombinedResult(trackResult());
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_QueryClientProvider = require("./QueryClientProvider.cjs");
+const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
+const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
+const require_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
+const require_suspense = require("./suspense.cjs");
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react, 1);
+let _tanstack_query_core = require("@tanstack/query-core");
+//#region src/useQueries.ts
+function useQueries({ queries, ...options }, queryClient) {
+	const client = require_QueryClientProvider.useQueryClient(queryClient);
+	const isRestoring = require_IsRestoringProvider.useIsRestoring();
+	const errorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary();
+	const subscribed = options.subscribed !== false;
+	const defaultedQueries = react.useMemo(() => queries.map((opts) => {
+		const defaultedOptions = client.defaultQueryOptions(opts);
+		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
+		return defaultedOptions;
+	}), [
+		queries,
+		client,
+		isRestoring,
+		subscribed
+	]);
+	defaultedQueries.forEach((queryOptions) => {
+		require_suspense.ensureSuspenseTimers(queryOptions);
+		const query = client.getQueryCache().get(queryOptions.queryHash);
+		require_errorBoundaryUtils.ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
+	});
+	require_errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
+	const [observer] = react.useState(() => new _tanstack_query_core.QueriesObserver(client, defaultedQueries, options));
+	const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
+	const shouldSubscribe = !isRestoring && subscribed;
+	react.useSyncExternalStore(react.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)) : _tanstack_query_core.noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	react.useEffect(() => {
+		observer.setQueries(defaultedQueries, options);
+	}, [
+		defaultedQueries,
+		options,
+		observer
+	]);
+	const suspensePromises = optimisticResult.some((result, index) => require_suspense.shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
+		const opts = defaultedQueries[index];
+		if (opts && require_suspense.shouldSuspend(opts, result)) {
+			const queryObserver = new _tanstack_query_core.QueryObserver(client, opts);
+			return require_suspense.fetchOptimistic(opts, queryObserver, errorResetBoundary);
+		}
+		return [];
+	}) : [];
+	if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
+	const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
+		const query = defaultedQueries[index];
+		return query && require_errorBoundaryUtils.getHasError({
+			result,
+			errorResetBoundary,
+			throwOnError: query.throwOnError,
+			query: client.getQueryCache().get(query.queryHash),
+			suspense: query.suspense
+		});
+	});
+	if (firstSingleResultWhichShouldThrow === null || firstSingleResultWhichShouldThrow === void 0 ? void 0 : firstSingleResultWhichShouldThrow.error) throw firstSingleResultWhichShouldThrow.error;
+	return getCombinedResult(trackResult());
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useQueries
-});
+//#endregion
+exports.useQueries = useQueries;
+
 //# sourceMappingURL=useQueries.cjs.map

package/build/legacy/useQueries.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n  QueriesObserver,\n  QueryObserver,\n  noop,\n  notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n  ensurePreventErrorBoundaryRetry,\n  getHasError,\n  useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n  ensureSuspenseTimers,\n  fetchOptimistic,\n  shouldSuspend,\n} from './suspense'\nimport type {\n  DefinedUseQueryResult,\n  UseQueryOptions,\n  UseQueryResult,\n} from './types'\nimport type {\n  DefaultError,\n  OmitKeyof,\n  QueriesObserverOptions,\n  QueriesPlaceholderDataFunction,\n  QueryClient,\n  QueryFunction,\n  QueryKey,\n  QueryObserverOptions,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'placeholderData' | 'subscribed'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseQueryOptionsForUseQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseQueryOptionsForUseQueries<\n                    TQueryFnData,\n                    unknown extends TError ? DefaultError : TError,\n                    unknown extends TData ? TQueryFnData : TData,\n                    TQueryKey\n                  >\n                : // Fallback\n                  UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n  initialData?: infer TInitialData\n}\n  ? unknown extends TInitialData\n    ? UseQueryResult<TData, TError>\n    : TInitialData extends TData\n      ? DefinedUseQueryResult<TData, TError>\n      : TInitialData extends () => infer TInitialDataResult\n        ? unknown extends TInitialDataResult\n          ? UseQueryResult<TData, TError>\n          : TInitialDataResult extends TData\n            ? DefinedUseQueryResult<TData, TError>\n            : UseQueryResult<TData, TError>\n        : UseQueryResult<TData, TError>\n  : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? GetDefinedOrUndefinedQueryResult<\n                    T,\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : // Fallback\n                  UseQueryResult\n\n/**\n * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type QueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseQueryOptionsForUseQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesOptions<\n            [...Tails],\n            [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                UseQueryOptionsForUseQueries<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                UseQueryOptionsForUseQueries<\n                  TQueryFnData,\n                  TError,\n                  TData,\n                  TQueryKey\n                >\n              >\n            : // Fallback\n              Array<UseQueryOptionsForUseQueries>\n\n/**\n * QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesResults<\n            [...Tails],\n            [...TResults, GetUseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  {\n    queries,\n    ...options\n  }: {\n    queries:\n      | readonly [...QueriesOptions<T>]\n      | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n    combine?: (result: QueriesResults<T>) => TCombinedResult\n    subscribed?: boolean\n  },\n  queryClient?: QueryClient,\n): TCombinedResult {\n  const client = useQueryClient(queryClient)\n  const isRestoring = useIsRestoring()\n  const errorResetBoundary = useQueryErrorResetBoundary()\n\n  const defaultedQueries = React.useMemo(\n    () =>\n      queries.map((opts) => {\n        const defaultedOptions = client.defaultQueryOptions(\n          opts as QueryObserverOptions,\n        )\n\n        // Make sure the results are already in fetching state before subscribing or updating options\n        defaultedOptions._optimisticResults = isRestoring\n          ? 'isRestoring'\n          : 'optimistic'\n\n        return defaultedOptions\n      }),\n    [queries, client, isRestoring],\n  )\n\n  defaultedQueries.forEach((queryOptions) => {\n    ensureSuspenseTimers(queryOptions)\n    const query = client.getQueryCache().get(queryOptions.queryHash)\n    ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n  })\n\n  useClearResetErrorBoundary(errorResetBoundary)\n\n  const [observer] = React.useState(\n    () =>\n      new QueriesObserver<TCombinedResult>(\n        client,\n        defaultedQueries,\n        options as QueriesObserverOptions<TCombinedResult>,\n      ),\n  )\n\n  // note: this must be called before useSyncExternalStore\n  const [optimisticResult, getCombinedResult, trackResult] =\n    observer.getOptimisticResult(\n      defaultedQueries,\n      (options as QueriesObserverOptions<TCombinedResult>).combine,\n    )\n\n  const shouldSubscribe = !isRestoring && options.subscribed !== false\n  React.useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) =>\n        shouldSubscribe\n          ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n          : noop,\n      [observer, shouldSubscribe],\n    ),\n    () => observer.getCurrentResult(),\n    () => observer.getCurrentResult(),\n  )\n\n  React.useEffect(() => {\n    observer.setQueries(\n      defaultedQueries,\n      options as QueriesObserverOptions<TCombinedResult>,\n    )\n  }, [defaultedQueries, options, observer])\n\n  const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n    shouldSuspend(defaultedQueries[index], result),\n  )\n\n  const suspensePromises = shouldAtLeastOneSuspend\n    ? optimisticResult.flatMap((result, index) => {\n        const opts = defaultedQueries[index]\n\n        if (opts && shouldSuspend(opts, result)) {\n          const queryObserver = new QueryObserver(client, opts)\n          return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n        }\n        return []\n      })\n    : []\n\n  if (suspensePromises.length > 0) {\n    throw Promise.all(suspensePromises)\n  }\n  const firstSingleResultWhichShouldThrow = optimisticResult.find(\n    (result, index) => {\n      const query = defaultedQueries[index]\n      return (\n        query &&\n        getHasError({\n          result,\n          errorResetBoundary,\n          throwOnError: query.throwOnError,\n          query: client.getQueryCache().get(query.queryHash),\n          suspense: query.suspense,\n        })\n      )\n    },\n  )\n\n  if (firstSingleResultWhichShouldThrow?.error) {\n    throw firstSingleResultWhichShouldThrow.error\n  }\n\n  return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAKO;AACP,iCAA+B;AAC/B,iCAA+B;AAC/B,qCAA2C;AAC3C,gCAIO;AACP,sBAIO;AAyLA,SAAS,WAId;AAAA,EACE;AAAA,EACA,GAAG;AACL,GAOA,aACiB;AACjB,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,kBAAc,2CAAe;AACnC,QAAM,yBAAqB,2DAA2B;AAEtD,QAAM,mBAAyB;AAAA,IAC7B,MACE,QAAQ,IAAI,CAAC,SAAS;AACpB,YAAM,mBAAmB,OAAO;AAAA,QAC9B;AAAA,MACF;AAGA,uBAAiB,qBAAqB,cAClC,gBACA;AAEJ,aAAO;AAAA,IACT,CAAC;AAAA,IACH,CAAC,SAAS,QAAQ,WAAW;AAAA,EAC/B;AAEA,mBAAiB,QAAQ,CAAC,iBAAiB;AACzC,8CAAqB,YAAY;AACjC,UAAM,QAAQ,OAAO,cAAc,EAAE,IAAI,aAAa,SAAS;AAC/D,mEAAgC,cAAc,oBAAoB,KAAK;AAAA,EACzE,CAAC;AAED,4DAA2B,kBAAkB;AAE7C,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,CAAC,kBAAkB,mBAAmB,WAAW,IACrD,SAAS;AAAA,IACP;AAAA,IACC,QAAoD;AAAA,EACvD;AAEF,QAAM,kBAAkB,CAAC,eAAe,QAAQ,eAAe;AAC/D,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBACC,kBACI,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC,IAC1D;AAAA,MACN,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS;AAAA,MACP;AAAA,MACA;AAAA,IACF;AAAA,EACF,GAAG,CAAC,kBAAkB,SAAS,QAAQ,CAAC;AAExC,QAAM,0BAA0B,iBAAiB;AAAA,IAAK,CAAC,QAAQ,cAC7D,+BAAc,iBAAiB,KAAK,GAAG,MAAM;AAAA,EAC/C;AAEA,QAAM,mBAAmB,0BACrB,iBAAiB,QAAQ,CAAC,QAAQ,UAAU;AAC1C,UAAM,OAAO,iBAAiB,KAAK;AAEnC,QAAI,YAAQ,+BAAc,MAAM,MAAM,GAAG;AACvC,YAAM,gBAAgB,IAAI,gCAAc,QAAQ,IAAI;AACpD,iBAAO,iCAAgB,MAAM,eAAe,kBAAkB;AAAA,IAChE;AACA,WAAO,CAAC;AAAA,EACV,CAAC,IACD,CAAC;AAEL,MAAI,iBAAiB,SAAS,GAAG;AAC/B,UAAM,QAAQ,IAAI,gBAAgB;AAAA,EACpC;AACA,QAAM,oCAAoC,iBAAiB;AAAA,IACzD,CAAC,QAAQ,UAAU;AACjB,YAAM,QAAQ,iBAAiB,KAAK;AACpC,aACE,aACA,uCAAY;AAAA,QACV;AAAA,QACA;AAAA,QACA,cAAc,MAAM;AAAA,QACpB,OAAO,OAAO,cAAc,EAAE,IAAI,MAAM,SAAS;AAAA,QACjD,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IAEL;AAAA,EACF;AAEA,MAAI,uFAAmC,OAAO;AAC5C,UAAM,kCAAkC;AAAA,EAC1C;AAEA,SAAO,kBAAkB,YAAY,CAAC;AACxC;","names":[]}
+{"version":3,"file":"useQueries.cjs","names":["useQueryClient","useIsRestoring","useQueryErrorResetBoundary","React","QueriesObserver","notifyManager","noop","shouldSuspend","QueryObserver","fetchOptimistic","getHasError"],"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n  QueriesObserver,\n  QueryObserver,\n  noop,\n  notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n  ensurePreventErrorBoundaryRetry,\n  getHasError,\n  useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n  ensureSuspenseTimers,\n  fetchOptimistic,\n  shouldSuspend,\n} from './suspense'\nimport type {\n  DefinedUseQueryResult,\n  UseQueryOptions,\n  UseQueryResult,\n} from './types'\nimport type {\n  DefaultError,\n  OmitKeyof,\n  QueriesObserverOptions,\n  QueriesPlaceholderDataFunction,\n  QueryClient,\n  QueryFunction,\n  QueryKey,\n  QueryObserverOptions,\n  ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'placeholderData' | 'subscribed'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseQueryOptionsForUseQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseQueryOptionsForUseQueries<\n                    TQueryFnData,\n                    unknown extends TError ? DefaultError : TError,\n                    unknown extends TData ? TQueryFnData : TData,\n                    TQueryKey\n                  >\n                : // Fallback\n                  UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n  initialData?: infer TInitialData\n}\n  ? unknown extends TInitialData\n    ? UseQueryResult<TData, TError>\n    : TInitialData extends TData\n      ? DefinedUseQueryResult<TData, TError>\n      : TInitialData extends () => infer TInitialDataResult\n        ? unknown extends TInitialDataResult\n          ? UseQueryResult<TData, TError>\n          : TInitialDataResult extends TData\n            ? DefinedUseQueryResult<TData, TError>\n            : UseQueryResult<TData, TError>\n        : UseQueryResult<TData, TError>\n  : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? GetDefinedOrUndefinedQueryResult<\n                    T,\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : // Fallback\n                  UseQueryResult\n\n/**\n * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type QueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseQueryOptionsForUseQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesOptions<\n            [...Tails],\n            [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                UseQueryOptionsForUseQueries<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                UseQueryOptionsForUseQueries<\n                  TQueryFnData,\n                  TError,\n                  TData,\n                  TQueryKey\n                >\n              >\n            : // Fallback\n              Array<UseQueryOptionsForUseQueries>\n\n/**\n * QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesResults<\n            [...Tails],\n            [...TResults, GetUseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  {\n    queries,\n    ...options\n  }: {\n    queries:\n      | readonly [...QueriesOptions<T>]\n      | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n    combine?: (result: QueriesResults<T>) => TCombinedResult\n    subscribed?: boolean\n  },\n  queryClient?: QueryClient,\n): TCombinedResult {\n  const client = useQueryClient(queryClient)\n  const isRestoring = useIsRestoring()\n  const errorResetBoundary = useQueryErrorResetBoundary()\n  const subscribed = options.subscribed !== false\n\n  const defaultedQueries = React.useMemo(\n    () =>\n      queries.map((opts) => {\n        const defaultedOptions = client.defaultQueryOptions(\n          opts as QueryObserverOptions,\n        )\n\n        // Make sure the results are already in fetching state before subscribing or updating options\n        defaultedOptions._optimisticResults = isRestoring\n          ? 'isRestoring'\n          : subscribed\n            ? 'optimistic'\n            : undefined\n\n        return defaultedOptions\n      }),\n    [queries, client, isRestoring, subscribed],\n  )\n\n  defaultedQueries.forEach((queryOptions) => {\n    ensureSuspenseTimers(queryOptions)\n    const query = client.getQueryCache().get(queryOptions.queryHash)\n    ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n  })\n\n  useClearResetErrorBoundary(errorResetBoundary)\n\n  const [observer] = React.useState(\n    () =>\n      new QueriesObserver<TCombinedResult>(\n        client,\n        defaultedQueries,\n        options as QueriesObserverOptions<TCombinedResult>,\n      ),\n  )\n\n  // note: this must be called before useSyncExternalStore\n  const [optimisticResult, getCombinedResult, trackResult] =\n    observer.getOptimisticResult(\n      defaultedQueries,\n      (options as QueriesObserverOptions<TCombinedResult>).combine,\n    )\n\n  const shouldSubscribe = !isRestoring && subscribed\n  React.useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) =>\n        shouldSubscribe\n          ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n          : noop,\n      [observer, shouldSubscribe],\n    ),\n    () => observer.getCurrentResult(),\n    () => observer.getCurrentResult(),\n  )\n\n  React.useEffect(() => {\n    observer.setQueries(\n      defaultedQueries,\n      options as QueriesObserverOptions<TCombinedResult>,\n    )\n  }, [defaultedQueries, options, observer])\n\n  const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n    shouldSuspend(defaultedQueries[index], result),\n  )\n\n  const suspensePromises = shouldAtLeastOneSuspend\n    ? optimisticResult.flatMap((result, index) => {\n        const opts = defaultedQueries[index]\n\n        if (opts && shouldSuspend(opts, result)) {\n          const queryObserver = new QueryObserver(client, opts)\n          return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n        }\n        return []\n      })\n    : []\n\n  if (suspensePromises.length > 0) {\n    throw Promise.all(suspensePromises)\n  }\n  const firstSingleResultWhichShouldThrow = optimisticResult.find(\n    (result, index) => {\n      const query = defaultedQueries[index]\n      return (\n        query &&\n        getHasError({\n          result,\n          errorResetBoundary,\n          throwOnError: query.throwOnError,\n          query: client.getQueryCache().get(query.queryHash),\n          suspense: query.suspense,\n        })\n      )\n    },\n  )\n\n  if (firstSingleResultWhichShouldThrow?.error) {\n    throw firstSingleResultWhichShouldThrow.error\n  }\n\n  return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;;;;AA8MA,SAAgB,WAId,EACE,SACA,GAAG,WAQL,aACiB;CACjB,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,MAAM,cAAcC,4BAAAA,eAAe;CACnC,MAAM,qBAAqBC,gCAAAA,2BAA2B;CACtD,MAAM,aAAa,QAAQ,eAAe;CAE1C,MAAM,mBAAmBC,MAAM,cAE3B,QAAQ,KAAK,SAAS;EACpB,MAAM,mBAAmB,OAAO,oBAC9B,IACF;EAGA,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;EAEN,OAAO;CACT,CAAC,GACH;EAAC;EAAS;EAAQ;EAAa;CAAU,CAC3C;CAEA,iBAAiB,SAAS,iBAAiB;EACzC,iBAAA,qBAAqB,YAAY;EACjC,MAAM,QAAQ,OAAO,cAAc,CAAC,CAAC,IAAI,aAAa,SAAS;EAC/D,2BAAA,gCAAgC,cAAc,oBAAoB,KAAK;CACzE,CAAC;CAED,2BAAA,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAYA,MAAM,eAErB,IAAIC,qBAAAA,gBACF,QACA,kBACA,OACF,CACJ;CAGA,MAAM,CAAC,kBAAkB,mBAAmB,eAC1C,SAAS,oBACP,kBACC,QAAoD,OACvD;CAEF,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJD,MAAM,aACH,kBACC,kBACI,SAAS,UAAUE,qBAAAA,cAAc,WAAW,aAAa,CAAC,IAC1DC,qBAAAA,MACN,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WACP,kBACA,OACF;CACF,GAAG;EAAC;EAAkB;EAAS;CAAQ,CAAC;CAMxC,MAAM,mBAJ0B,iBAAiB,MAAM,QAAQ,UAC7DC,iBAAAA,cAAc,iBAAiB,QAAQ,MAAM,CAGA,IAC3C,iBAAiB,SAAS,QAAQ,UAAU;EAC1C,MAAM,OAAO,iBAAiB;EAE9B,IAAI,QAAQA,iBAAAA,cAAc,MAAM,MAAM,GAAG;GACvC,MAAM,gBAAgB,IAAIC,qBAAAA,cAAc,QAAQ,IAAI;GACpD,OAAOC,iBAAAA,gBAAgB,MAAM,eAAe,kBAAkB;EAChE;EACA,OAAO,CAAC;CACV,CAAC,IACD,CAAC;CAEL,IAAI,iBAAiB,SAAS,GAC5B,MAAM,QAAQ,IAAI,gBAAgB;CAEpC,MAAM,oCAAoC,iBAAiB,MACxD,QAAQ,UAAU;EACjB,MAAM,QAAQ,iBAAiB;EAC/B,OACE,SACAC,2BAAAA,YAAY;GACV;GACA;GACA,cAAc,MAAM;GACpB,OAAO,OAAO,cAAc,CAAC,CAAC,IAAI,MAAM,SAAS;GACjD,UAAU,MAAM;EAClB,CAAC;CAEL,CACF;CAEA,IAAA,sCAAA,QAAA,sCAAA,KAAA,IAAA,KAAA,IAAI,kCAAmC,OACrC,MAAM,kCAAkC;CAG1C,OAAO,kBAAkB,YAAY,CAAC;AACxC"}

package/build/legacy/useQueries.d.cts

@@ -1,3 +1,57 @@
-export { useQueries_alias_1 as useQueries } from './_tsup-dts-rollup.cjs';
-export { QueriesOptions_alias_1 as QueriesOptions } from './_tsup-dts-rollup.cjs';
-export { QueriesResults_alias_1 as QueriesResults } from './_tsup-dts-rollup.cjs';
+import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.cjs";
+import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
+//#region src/useQueries.d.ts
+type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'subscribed'> & {
+  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
+type MAXIMUM_DEPTH = 20;
+type SkipTokenForUseQueries = symbol;
+type GetUseQueryOptionsForUseQueries<T> = T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+  data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+  data: infer TData;
+  error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+  queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
+type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
+  initialData?: infer TInitialData;
+} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
+type GetUseQueryResult<T> = T extends {
+  queryFnData: any;
+  error?: infer TError;
+  data: infer TData;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
+  data: infer TData;
+  error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
+  queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetUseQueryOptionsForUseQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetUseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseQueryResult<T[K]>; };
+declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
+  queries: readonly [...QueriesOptions<T>] | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>; }];
+  combine?: (result: QueriesResults<T>) => TCombinedResult;
+  subscribed?: boolean;
+}, queryClient?: QueryClient): TCombinedResult;
+//#endregion
+export { QueriesOptions, QueriesResults, useQueries };
+//# sourceMappingURL=useQueries.d.cts.map

package/build/legacy/useQueries.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueries.d.cts","names":[],"sources":["../../src/useQueries.ts"],"mappings":";;;KAyCK,6BACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,gCAAgC,KAEnC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,6BAA6B,cAAc,QAAQ,SACnD;EAAY,mBAAmB;EAAc,cAAc;IACzD,6BAA6B,cAAc,UAC3C;EAAY,YAAY;EAAO,cAAc;IAC3C,sCAAsC,QAAQ,SAE9C,iBAAiB,oBAAoB,cAAc,SACjD,6BAA6B,cAAc,QAAQ,SACnD,iBAAiB,oBAAoB,UACnC,6BAA6B,cAAc,UAC3C,iBAAiB,gBACf,6BAA6B,gBAE7B;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,6BACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,eAAe,OAAO,UACtB,qBAAqB,QACnB,sBAAsB,OAAO,UAC7B,kCAAiC,sCACf,qBACd,eAAe,OAAO,UACtB,2BAA2B,QACzB,sBAAsB,OAAO,UAC7B,eAAe,OAAO,UAC1B,eAAe,OAAO,UAC5B,eAAe,OAAO;KAErB,kBAAkB,KAErB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;KAKN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,gCACN,oBAEE,iBAAiB,YACX,UAAU,gCAAgC,SAC9C,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,gCAAgC,YAC1C,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,mCACQ,oBACA,cACA,aACA,cAGV,MACE,6BACE,cACA,QACA,OACA,cAIJ,MAAM;;;;KAKR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,kBACN,oBAEE,iBAAiB,YACX,UAAU,kBAAkB,SAChC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,kBAAkB,YAC5B,iBAEH,WAAW,IAAI,kBAAkB,EAAE;iBAEhC,WACd,UAAU,YACV,kBAAkB,eAAe,MAG/B,YACG;EAEH,sBACiB,eAAe,sBACZ,WAAW,IAAI,gCAAgC,EAAE;EACrE,WAAW,QAAQ,eAAe,OAAO;EACzC;GAEF,cAAc,cACb"}

package/build/legacy/useQueries.d.ts

@@ -1,3 +1,57 @@
-export { useQueries_alias_1 as useQueries } from './_tsup-dts-rollup.js';
-export { QueriesOptions_alias_1 as QueriesOptions } from './_tsup-dts-rollup.js';
-export { QueriesResults_alias_1 as QueriesResults } from './_tsup-dts-rollup.js';
+import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.js";
+import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
+//#region src/useQueries.d.ts
+type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'subscribed'> & {
+  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
+type MAXIMUM_DEPTH = 20;
+type SkipTokenForUseQueries = symbol;
+type GetUseQueryOptionsForUseQueries<T> = T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+  data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+  data: infer TData;
+  error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+  queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
+type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
+  initialData?: infer TInitialData;
+} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
+type GetUseQueryResult<T> = T extends {
+  queryFnData: any;
+  error?: infer TError;
+  data: infer TData;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
+  queryFnData: infer TQueryFnData;
+  error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
+  data: infer TData;
+  error?: infer TError;
+} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
+  queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+  select?: (data: any) => infer TData;
+  throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetUseQueryOptionsForUseQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetUseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseQueryResult<T[K]>; };
+declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
+  queries: readonly [...QueriesOptions<T>] | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>; }];
+  combine?: (result: QueriesResults<T>) => TCombinedResult;
+  subscribed?: boolean;
+}, queryClient?: QueryClient): TCombinedResult;
+//#endregion
+export { QueriesOptions, QueriesResults, useQueries };
+//# sourceMappingURL=useQueries.d.ts.map

package/build/legacy/useQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueries.d.ts","names":[],"sources":["../../src/useQueries.ts"],"mappings":";;;KAyCK,6BACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,gCAAgC,KAEnC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,6BAA6B,cAAc,QAAQ,SACnD;EAAY,mBAAmB;EAAc,cAAc;IACzD,6BAA6B,cAAc,UAC3C;EAAY,YAAY;EAAO,cAAc;IAC3C,sCAAsC,QAAQ,SAE9C,iBAAiB,oBAAoB,cAAc,SACjD,6BAA6B,cAAc,QAAQ,SACnD,iBAAiB,oBAAoB,UACnC,6BAA6B,cAAc,UAC3C,iBAAiB,gBACf,6BAA6B,gBAE7B;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,6BACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,eAAe,OAAO,UACtB,qBAAqB,QACnB,sBAAsB,OAAO,UAC7B,kCAAiC,sCACf,qBACd,eAAe,OAAO,UACtB,2BAA2B,QACzB,sBAAsB,OAAO,UAC7B,eAAe,OAAO,UAC1B,eAAe,OAAO,UAC5B,eAAe,OAAO;KAErB,kBAAkB,KAErB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;KAKN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,gCACN,oBAEE,iBAAiB,YACX,UAAU,gCAAgC,SAC9C,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,gCAAgC,YAC1C,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,mCACQ,oBACA,cACA,aACA,cAGV,MACE,6BACE,cACA,QACA,OACA,cAIJ,MAAM;;;;KAKR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,kBACN,oBAEE,iBAAiB,YACX,UAAU,kBAAkB,SAChC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,kBAAkB,YAC5B,iBAEH,WAAW,IAAI,kBAAkB,EAAE;iBAEhC,WACd,UAAU,YACV,kBAAkB,eAAe,MAG/B,YACG;EAEH,sBACiB,eAAe,sBACZ,WAAW,IAAI,gCAAgC,EAAE;EACrE,WAAW,QAAQ,eAAe,OAAO;EACzC;GAEF,cAAc,cACb"}

package/build/legacy/useQueries.js

@@ -1,107 +1,67 @@
 "use client";
-
-// src/useQueries.ts
-import * as React from "react";
-import {
-  QueriesObserver,
-  QueryObserver,
-  noop,
-  notifyManager
-} from "@tanstack/query-core";
 import { useQueryClient } from "./QueryClientProvider.js";
 import { useIsRestoring } from "./IsRestoringProvider.js";
 import { useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
-import {
-  ensurePreventErrorBoundaryRetry,
-  getHasError,
-  useClearResetErrorBoundary
-} from "./errorBoundaryUtils.js";
-import {
-  ensureSuspenseTimers,
-  fetchOptimistic,
-  shouldSuspend
-} from "./suspense.js";
-function useQueries({
-  queries,
-  ...options
-}, queryClient) {
-  const client = useQueryClient(queryClient);
-  const isRestoring = useIsRestoring();
-  const errorResetBoundary = useQueryErrorResetBoundary();
-  const defaultedQueries = React.useMemo(
-    () => queries.map((opts) => {
-      const defaultedOptions = client.defaultQueryOptions(
-        opts
-      );
-      defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
-      return defaultedOptions;
-    }),
-    [queries, client, isRestoring]
-  );
-  defaultedQueries.forEach((queryOptions) => {
-    ensureSuspenseTimers(queryOptions);
-    const query = client.getQueryCache().get(queryOptions.queryHash);
-    ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
-  });
-  useClearResetErrorBoundary(errorResetBoundary);
-  const [observer] = React.useState(
-    () => new QueriesObserver(
-      client,
-      defaultedQueries,
-      options
-    )
-  );
-  const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
-    defaultedQueries,
-    options.combine
-  );
-  const shouldSubscribe = !isRestoring && options.subscribed !== false;
-  React.useSyncExternalStore(
-    React.useCallback(
-      (onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop,
-      [observer, shouldSubscribe]
-    ),
-    () => observer.getCurrentResult(),
-    () => observer.getCurrentResult()
-  );
-  React.useEffect(() => {
-    observer.setQueries(
-      defaultedQueries,
-      options
-    );
-  }, [defaultedQueries, options, observer]);
-  const shouldAtLeastOneSuspend = optimisticResult.some(
-    (result, index) => shouldSuspend(defaultedQueries[index], result)
-  );
-  const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
-    const opts = defaultedQueries[index];
-    if (opts && shouldSuspend(opts, result)) {
-      const queryObserver = new QueryObserver(client, opts);
-      return fetchOptimistic(opts, queryObserver, errorResetBoundary);
-    }
-    return [];
-  }) : [];
-  if (suspensePromises.length > 0) {
-    throw Promise.all(suspensePromises);
-  }
-  const firstSingleResultWhichShouldThrow = optimisticResult.find(
-    (result, index) => {
-      const query = defaultedQueries[index];
-      return query && getHasError({
-        result,
-        errorResetBoundary,
-        throwOnError: query.throwOnError,
-        query: client.getQueryCache().get(query.queryHash),
-        suspense: query.suspense
-      });
-    }
-  );
-  if (firstSingleResultWhichShouldThrow == null ? void 0 : firstSingleResultWhichShouldThrow.error) {
-    throw firstSingleResultWhichShouldThrow.error;
-  }
-  return getCombinedResult(trackResult());
+import { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary } from "./errorBoundaryUtils.js";
+import { ensureSuspenseTimers, fetchOptimistic, shouldSuspend } from "./suspense.js";
+import * as React from "react";
+import { QueriesObserver, QueryObserver, noop, notifyManager } from "@tanstack/query-core";
+//#region src/useQueries.ts
+function useQueries({ queries, ...options }, queryClient) {
+	const client = useQueryClient(queryClient);
+	const isRestoring = useIsRestoring();
+	const errorResetBoundary = useQueryErrorResetBoundary();
+	const subscribed = options.subscribed !== false;
+	const defaultedQueries = React.useMemo(() => queries.map((opts) => {
+		const defaultedOptions = client.defaultQueryOptions(opts);
+		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
+		return defaultedOptions;
+	}), [
+		queries,
+		client,
+		isRestoring,
+		subscribed
+	]);
+	defaultedQueries.forEach((queryOptions) => {
+		ensureSuspenseTimers(queryOptions);
+		const query = client.getQueryCache().get(queryOptions.queryHash);
+		ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
+	});
+	useClearResetErrorBoundary(errorResetBoundary);
+	const [observer] = React.useState(() => new QueriesObserver(client, defaultedQueries, options));
+	const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
+	const shouldSubscribe = !isRestoring && subscribed;
+	React.useSyncExternalStore(React.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	React.useEffect(() => {
+		observer.setQueries(defaultedQueries, options);
+	}, [
+		defaultedQueries,
+		options,
+		observer
+	]);
+	const suspensePromises = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
+		const opts = defaultedQueries[index];
+		if (opts && shouldSuspend(opts, result)) {
+			const queryObserver = new QueryObserver(client, opts);
+			return fetchOptimistic(opts, queryObserver, errorResetBoundary);
+		}
+		return [];
+	}) : [];
+	if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
+	const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
+		const query = defaultedQueries[index];
+		return query && getHasError({
+			result,
+			errorResetBoundary,
+			throwOnError: query.throwOnError,
+			query: client.getQueryCache().get(query.queryHash),
+			suspense: query.suspense
+		});
+	});
+	if (firstSingleResultWhichShouldThrow === null || firstSingleResultWhichShouldThrow === void 0 ? void 0 : firstSingleResultWhichShouldThrow.error) throw firstSingleResultWhichShouldThrow.error;
+	return getCombinedResult(trackResult());
 }
-export {
-  useQueries
-};
+//#endregion
+export { useQueries };
+
 //# sourceMappingURL=useQueries.js.map