@suspensive/react-query-4 0.0.1-beta.0

package/dist/useSuspenseInfiniteQuery.cjs

@@ -0,0 +1,56 @@
+"use client"
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useSuspenseInfiniteQuery.ts
+var useSuspenseInfiniteQuery_exports = {};
+__export(useSuspenseInfiniteQuery_exports, {
+  useSuspenseInfiniteQuery: () => useSuspenseInfiniteQuery
+});
+module.exports = __toCommonJS(useSuspenseInfiniteQuery_exports);
+var import_react_query = require("@tanstack/react-query");
+function useSuspenseInfiniteQuery(options) {
+  return (0, import_react_query.useInfiniteQuery)(__spreadProps(__spreadValues({}, options), {
+    enabled: true,
+    suspense: true,
+    useErrorBoundary: true
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSuspenseInfiniteQuery
+});
+//# sourceMappingURL=useSuspenseInfiniteQuery.cjs.map

package/dist/useSuspenseInfiniteQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["import {\n  type InfiniteData,\n  type QueryKey,\n  type UseInfiniteQueryOptions,\n  type UseInfiniteQueryResult,\n  useInfiniteQuery,\n} from '@tanstack/react-query'\nimport type { OmitKeyof } from './utility-types'\n\nexport interface UseSuspenseInfiniteQueryResult<TData = unknown, TError = unknown>\n  extends OmitKeyof<\n    UseInfiniteQueryResult<TData, TError>,\n    keyof Pick<UseInfiniteQueryResult<TData, TError>, 'isPlaceholderData'>\n  > {\n  data: InfiniteData<TData>\n  status: 'success'\n}\n\nexport interface UseSuspenseInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n    UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n    'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData'\n  > {}\n\n/**\n * This hook is wrapping useInfiniteQuery of `@tanstack/react-query` v4 with default suspense option.\n * @see {@link https://suspensive.org/docs/react-query/useSuspenseInfiniteQuery}\n */\nexport function useSuspenseInfiniteQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n  return useInfiniteQuery({\n    ...options,\n    enabled: true,\n    suspense: true,\n    useErrorBoundary: true,\n  }) as UseSuspenseInfiniteQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAMO;AA0BA,SAAS,yBAMd,SAC+C;AAC/C,aAAO,qCAAiB,iCACnB,UADmB;AAAA,IAEtB,SAAS;AAAA,IACT,UAAU;AAAA,IACV,kBAAkB;AAAA,EACpB,EAAC;AACH;","names":[]}

package/dist/useSuspenseInfiniteQuery.d.cts

@@ -0,0 +1,16 @@
+import { UseInfiniteQueryResult, InfiniteData, QueryKey, UseInfiniteQueryOptions } from '@tanstack/react-query';
+import { O as OmitKeyof } from './OmitKeyof-CFsZLI4k.cjs';
+
+interface UseSuspenseInfiniteQueryResult<TData = unknown, TError = unknown> extends OmitKeyof<UseInfiniteQueryResult<TData, TError>, keyof Pick<UseInfiniteQueryResult<TData, TError>, 'isPlaceholderData'>> {
+    data: InfiniteData<TData>;
+    status: 'success';
+}
+interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData'> {
+}
+/**
+ * This hook is wrapping useInfiniteQuery of `@tanstack/react-query` v4 with default suspense option.
+ * @see {@link https://suspensive.org/docs/react-query/useSuspenseInfiniteQuery}
+ */
+declare function useSuspenseInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseInfiniteQueryResult<TData, TError>;
+
+export { type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery };

package/dist/useSuspenseInfiniteQuery.d.ts

@@ -0,0 +1,16 @@
+import { UseInfiniteQueryResult, InfiniteData, QueryKey, UseInfiniteQueryOptions } from '@tanstack/react-query';
+import { O as OmitKeyof } from './OmitKeyof-CFsZLI4k.js';
+
+interface UseSuspenseInfiniteQueryResult<TData = unknown, TError = unknown> extends OmitKeyof<UseInfiniteQueryResult<TData, TError>, keyof Pick<UseInfiniteQueryResult<TData, TError>, 'isPlaceholderData'>> {
+    data: InfiniteData<TData>;
+    status: 'success';
+}
+interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData'> {
+}
+/**
+ * This hook is wrapping useInfiniteQuery of `@tanstack/react-query` v4 with default suspense option.
+ * @see {@link https://suspensive.org/docs/react-query/useSuspenseInfiniteQuery}
+ */
+declare function useSuspenseInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseInfiniteQueryResult<TData, TError>;
+
+export { type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, useSuspenseInfiniteQuery };

package/dist/useSuspenseInfiniteQuery.js

@@ -0,0 +1,9 @@
+"use client"
+import {
+  useSuspenseInfiniteQuery
+} from "./chunk-3B63MBHY.js";
+import "./chunk-QETBZSG5.js";
+export {
+  useSuspenseInfiniteQuery
+};
+//# sourceMappingURL=useSuspenseInfiniteQuery.js.map

package/dist/useSuspenseInfiniteQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/useSuspenseQueries.cjs

@@ -0,0 +1,58 @@
+"use client"
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useSuspenseQueries.ts
+var useSuspenseQueries_exports = {};
+__export(useSuspenseQueries_exports, {
+  useSuspenseQueries: () => useSuspenseQueries
+});
+module.exports = __toCommonJS(useSuspenseQueries_exports);
+var import_react_query = require("@tanstack/react-query");
+function useSuspenseQueries({
+  queries,
+  context
+}) {
+  return (0, import_react_query.useQueries)({
+    queries: queries.map((query) => __spreadProps(__spreadValues({}, query), { suspense: true })),
+    context
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSuspenseQueries
+});
+//# sourceMappingURL=useSuspenseQueries.cjs.map

package/dist/useSuspenseQueries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useSuspenseQueries.ts"],"sourcesContent":["import { type QueryFunction, type UseQueryOptions, useQueries } from '@tanstack/react-query'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\ntype GetSuspenseOptions<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    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryOptions<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryOptions<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          ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryOptions<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryOptions<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>\n                    select?: (data: any) => infer TData\n                  }\n                ? UseSuspenseQueryOptions<TQueryFnData, unknown, TData, TQueryKey>\n                : T extends {\n                      queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>\n                    }\n                  ? UseSuspenseQueryOptions<TQueryFnData, unknown, TQueryFnData, TQueryKey>\n                  : // Fallback\n                    UseSuspenseQueryOptions\n\ntype GetSuspenseResults<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    ? UseSuspenseQueryResult<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryResult<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          ? UseSuspenseQueryResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?: QueryFunction<infer TQueryFnData, any>\n                    select?: (data: any) => infer TData\n                  }\n                ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData>\n                : T extends {\n                      queryFn?: QueryFunction<infer TQueryFnData, any>\n                    }\n                  ? UseSuspenseQueryResult<TQueryFnData>\n                  : // Fallback\n                    UseSuspenseQueryResult\n\n/**\n * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type SuspenseQueriesOptions<\n  T extends Array<any>,\n  TResult extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryOptions>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResult, GetSuspenseOptions<Head>]\n      : T extends [infer Head, ...infer Tail]\n        ? SuspenseQueriesOptions<[...Tail], [...TResult, GetSuspenseOptions<Head>], [...TDepth, 1]>\n        : Array<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>>\n            ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>>\n            : // Fallback\n              Array<UseSuspenseQueryOptions>\n\n/**\n * SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResult extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResult, GetSuspenseResults<Head>]\n      : T extends [infer Head, ...infer Tail]\n        ? SuspenseQueriesResults<[...Tail], [...TResult, GetSuspenseResults<Head>], [...TDepth, 1]>\n        : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, any>>\n          ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results\n            Array<UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>>\n          : // Fallback\n            Array<UseSuspenseQueryResult>\n\n/**\n * This hook is wrapping useQueries of `@tanstack/react-query` v4 with default suspense option.\n * @see {@link https://suspensive.org/docs/react-query/useSuspenseQueries}\n */\nexport function useSuspenseQueries<T extends any[]>({\n  queries,\n  context,\n}: {\n  queries: readonly [...SuspenseQueriesOptions<T>]\n  context?: UseQueryOptions['context']\n}): SuspenseQueriesResults<T> {\n  return useQueries({\n    queries: queries.map((query: typeof queries) => ({ ...query, suspense: true })),\n    context,\n  }) as SuspenseQueriesResults<T>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAqE;AAmH9D,SAAS,mBAAoC;AAAA,EAClD;AAAA,EACA;AACF,GAG8B;AAC5B,aAAO,+BAAW;AAAA,IAChB,SAAS,QAAQ,IAAI,CAAC,UAA2B,iCAAK,QAAL,EAAY,UAAU,KAAK,EAAE;AAAA,IAC9E;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/useSuspenseQueries.d.cts

@@ -0,0 +1,55 @@
+import { UseQueryOptions, QueryFunction } from '@tanstack/react-query';
+import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery.cjs';
+import './OmitKeyof-CFsZLI4k.cjs';
+
+type MAXIMUM_DEPTH = 20;
+type GetSuspenseOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select?: (data: any) => infer TData;
+} ? UseSuspenseQueryOptions<TQueryFnData, unknown, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? UseSuspenseQueryOptions<TQueryFnData, unknown, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
+type GetSuspenseResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseSuspenseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+    select?: (data: any) => infer TData;
+} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? UseSuspenseQueryResult<TQueryFnData> : UseSuspenseQueryResult;
+/**
+ * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type SuspenseQueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetSuspenseOptions<Head>] : T extends [infer Head, ...infer Tail] ? SuspenseQueriesOptions<[...Tail], [...TResult, GetSuspenseOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
+/**
+ * SuspenseQueriesResults reducer recursively maps type param to results
+ */
+type SuspenseQueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetSuspenseResults<Head>] : T extends [infer Head, ...infer Tail] ? SuspenseQueriesResults<[...Tail], [...TResult, GetSuspenseResults<Head>], [...TDepth, 1]> : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, any>> ? Array<UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>> : Array<UseSuspenseQueryResult>;
+/**
+ * This hook is wrapping useQueries of `@tanstack/react-query` v4 with default suspense option.
+ * @see {@link https://suspensive.org/docs/react-query/useSuspenseQueries}
+ */
+declare function useSuspenseQueries<T extends any[]>({ queries, context, }: {
+    queries: readonly [...SuspenseQueriesOptions<T>];
+    context?: UseQueryOptions['context'];
+}): SuspenseQueriesResults<T>;
+
+export { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries };

package/dist/useSuspenseQueries.d.ts

@@ -0,0 +1,55 @@
+import { UseQueryOptions, QueryFunction } from '@tanstack/react-query';
+import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery.js';
+import './OmitKeyof-CFsZLI4k.js';
+
+type MAXIMUM_DEPTH = 20;
+type GetSuspenseOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select?: (data: any) => infer TData;
+} ? UseSuspenseQueryOptions<TQueryFnData, unknown, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? UseSuspenseQueryOptions<TQueryFnData, unknown, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
+type GetSuspenseResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseSuspenseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+    select?: (data: any) => infer TData;
+} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? UseSuspenseQueryResult<TQueryFnData> : UseSuspenseQueryResult;
+/**
+ * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type SuspenseQueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetSuspenseOptions<Head>] : T extends [infer Head, ...infer Tail] ? SuspenseQueriesOptions<[...Tail], [...TResult, GetSuspenseOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
+/**
+ * SuspenseQueriesResults reducer recursively maps type param to results
+ */
+type SuspenseQueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetSuspenseResults<Head>] : T extends [infer Head, ...infer Tail] ? SuspenseQueriesResults<[...Tail], [...TResult, GetSuspenseResults<Head>], [...TDepth, 1]> : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, any>> ? Array<UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>> : Array<UseSuspenseQueryResult>;
+/**
+ * This hook is wrapping useQueries of `@tanstack/react-query` v4 with default suspense option.
+ * @see {@link https://suspensive.org/docs/react-query/useSuspenseQueries}
+ */
+declare function useSuspenseQueries<T extends any[]>({ queries, context, }: {
+    queries: readonly [...SuspenseQueriesOptions<T>];
+    context?: UseQueryOptions['context'];
+}): SuspenseQueriesResults<T>;
+
+export { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries };

package/dist/useSuspenseQueries.js

@@ -0,0 +1,9 @@
+"use client"
+import {
+  useSuspenseQueries
+} from "./chunk-S7L2LUVS.js";
+import "./chunk-QETBZSG5.js";
+export {
+  useSuspenseQueries
+};
+//# sourceMappingURL=useSuspenseQueries.js.map

package/dist/useSuspenseQueries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/useSuspenseQuery.cjs

@@ -0,0 +1,56 @@
+"use client"
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useSuspenseQuery.ts
+var useSuspenseQuery_exports = {};
+__export(useSuspenseQuery_exports, {
+  useSuspenseQuery: () => useSuspenseQuery
+});
+module.exports = __toCommonJS(useSuspenseQuery_exports);
+var import_react_query = require("@tanstack/react-query");
+function useSuspenseQuery(options) {
+  return (0, import_react_query.useQuery)(__spreadProps(__spreadValues({}, options), {
+    enabled: true,
+    useErrorBoundary: true,
+    suspense: true
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSuspenseQuery
+});
+//# sourceMappingURL=useSuspenseQuery.cjs.map

package/dist/useSuspenseQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useSuspenseQuery.ts"],"sourcesContent":["import { type QueryKey, type UseQueryOptions, type UseQueryResult, useQuery } from '@tanstack/react-query'\nimport type { OmitKeyof } from './utility-types'\n\nexport interface UseSuspenseQueryResult<TData = unknown, TError = unknown>\n  extends OmitKeyof<UseQueryResult<TData, TError>, keyof Pick<UseQueryResult, 'isPlaceholderData'>> {\n  data: TData\n  status: 'success'\n}\n\nexport interface UseSuspenseQueryOptions<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData'\n  > {}\n\n/**\n * This hook is wrapping useQuery of `@tanstack/react-query` v4 with default suspense option.\n * @see {@link https://suspensive.org/docs/react-query/useSuspenseQuery}\n */\nexport function useSuspenseQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>) {\n  return useQuery<TQueryFnData, TError, TData, TQueryKey>({\n    ...options,\n    enabled: true,\n    useErrorBoundary: true,\n    suspense: true,\n  }) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAmF;AAuB5E,SAAS,iBAKd,SAA0E;AAC1E,aAAO,6BAAiD,iCACnD,UADmD;AAAA,IAEtD,SAAS;AAAA,IACT,kBAAkB;AAAA,IAClB,UAAU;AAAA,EACZ,EAAC;AACH;","names":[]}

package/dist/useSuspenseQuery.d.cts

@@ -0,0 +1,16 @@
+import { UseQueryResult, QueryKey, UseQueryOptions } from '@tanstack/react-query';
+import { O as OmitKeyof } from './OmitKeyof-CFsZLI4k.cjs';
+
+interface UseSuspenseQueryResult<TData = unknown, TError = unknown> extends OmitKeyof<UseQueryResult<TData, TError>, keyof Pick<UseQueryResult, 'isPlaceholderData'>> {
+    data: TData;
+    status: 'success';
+}
+interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData'> {
+}
+/**
+ * This hook is wrapping useQuery of `@tanstack/react-query` v4 with default suspense option.
+ * @see {@link https://suspensive.org/docs/react-query/useSuspenseQuery}
+ */
+declare function useSuspenseQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
+
+export { type UseSuspenseQueryOptions, type UseSuspenseQueryResult, useSuspenseQuery };

package/dist/useSuspenseQuery.d.ts

@@ -0,0 +1,16 @@
+import { UseQueryResult, QueryKey, UseQueryOptions } from '@tanstack/react-query';
+import { O as OmitKeyof } from './OmitKeyof-CFsZLI4k.js';
+
+interface UseSuspenseQueryResult<TData = unknown, TError = unknown> extends OmitKeyof<UseQueryResult<TData, TError>, keyof Pick<UseQueryResult, 'isPlaceholderData'>> {
+    data: TData;
+    status: 'success';
+}
+interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'suspense' | 'useErrorBoundary' | 'enabled' | 'placeholderData'> {
+}
+/**
+ * This hook is wrapping useQuery of `@tanstack/react-query` v4 with default suspense option.
+ * @see {@link https://suspensive.org/docs/react-query/useSuspenseQuery}
+ */
+declare function useSuspenseQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseSuspenseQueryResult<TData, TError>;
+
+export { type UseSuspenseQueryOptions, type UseSuspenseQueryResult, useSuspenseQuery };

package/dist/useSuspenseQuery.js

@@ -0,0 +1,9 @@
+"use client"
+import {
+  useSuspenseQuery
+} from "./chunk-J3EHCRU6.js";
+import "./chunk-QETBZSG5.js";
+export {
+  useSuspenseQuery
+};
+//# sourceMappingURL=useSuspenseQuery.js.map

package/dist/useSuspenseQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@suspensive/react-query-4",
+  "version": "0.0.1-beta.0",
+  "description": "Useful helpers for @tanstack/react-query@4 with suspense",
+  "keywords": [
+    "suspensive",
+    "react",
+    "react-query"
+  ],
+  "homepage": "https://suspensive.org",
+  "bugs": "https://github.com/toss/suspensive/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/toss/suspensive.git",
+    "directory": "packages/react-query"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Jonghyeon Ko",
+    "email": "jonghyeon@toss.im"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "@tanstack/react-query": "^4.36.1",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "@suspensive/eslint-config": "0.0.0",
+    "@suspensive/react": "2.1.2-beta.0",
+    "@suspensive/test-utils": "0.0.0",
+    "@suspensive/tsconfig": "0.0.0-development",
+    "@suspensive/tsup": "0.0.0"
+  },
+  "peerDependencies": {
+    "@suspensive/react": "^2.1.2-beta.0",
+    "@tanstack/react-query": "^4",
+    "react": "^18"
+  },
+  "peerDependenciesMeta": {
+    "@suspensive/react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "ci:attw": "attw --pack",
+    "ci:eslint": "eslint \"**/*.{js,jsx,cjs,mjs,ts,tsx,cts,mts}\"",
+    "ci:publint": "publint --strict",
+    "ci:test": "vitest run --coverage --typecheck",
+    "ci:test:watch": "vitest --ui --coverage --typecheck",
+    "ci:type": "tsc --noEmit",
+    "clean": "rimraf ./dist && rimraf ./coverage",
+    "dev": "tsup --watch"
+  }
+}

package/src/QueryErrorBoundary.tsx

@@ -0,0 +1,27 @@
+import { ErrorBoundary } from '@suspensive/react'
+import { useQueryErrorResetBoundary } from '@tanstack/react-query'
+import { type ComponentPropsWithoutRef, type ComponentRef, forwardRef } from 'react'
+
+/**
+ * This component wrapping QueryErrorResetBoundary of `@tanstack/react-query` with `@suspensive/react`'s ErrorBoundary. So you must install `@suspensive/react` first, then use it. with this component, You don't have to make unnecessary repetitive implementation to combine ErrorBoundary with QueryErrorResetBoundary
+ * @see {@link https://suspensive.org/docs/react-query/QueryErrorBoundary}
+ */
+export const QueryErrorBoundary = forwardRef<
+  ComponentRef<typeof ErrorBoundary>,
+  ComponentPropsWithoutRef<typeof ErrorBoundary>
+>(({ onReset, ...props }, resetRef) => {
+  const { reset } = useQueryErrorResetBoundary()
+  return (
+    <ErrorBoundary
+      {...props}
+      onReset={() => {
+        onReset?.()
+        reset()
+      }}
+      ref={resetRef}
+    />
+  )
+})
+if (process.env.NODE_ENV === 'development') {
+  QueryErrorBoundary.displayName = 'QueryErrorBoundary'
+}

package/src/SuspenseInfiniteQuery.test-d.tsx

@@ -0,0 +1,102 @@
+import { queryFn, queryKey } from '@suspensive/test-utils'
+import type { InfiniteData } from '@tanstack/react-query'
+import type { ReactNode } from 'react'
+import { describe, expectTypeOf, it } from 'vitest'
+import { SuspenseInfiniteQuery } from './SuspenseInfiniteQuery'
+import type { UseSuspenseInfiniteQueryResult } from './useSuspenseInfiniteQuery'
+
+describe('<SuspenseInfiniteQuery/>', () => {
+  it('type error', () => {
+    ;() => (
+      <SuspenseInfiniteQuery
+        queryKey={queryKey}
+        queryFn={queryFn}
+        //@ts-expect-error no suspense
+        suspense={boolean}
+      >
+        {(query) => <>{query.data.pages.filter(({ text }) => text)}</>}
+      </SuspenseInfiniteQuery>
+    )
+    ;() => (
+      <SuspenseInfiniteQuery
+        queryKey={queryKey}
+        queryFn={queryFn}
+        //@ts-expect-error no useErrorBoundary
+        useErrorBoundary={boolean}
+      >
+        {(query) => <>{query.data.pages.filter(({ text }) => text)}</>}
+      </SuspenseInfiniteQuery>
+    )
+    ;() => (
+      <SuspenseInfiniteQuery
+        queryKey={queryKey}
+        queryFn={queryFn}
+        //@ts-expect-error no enabled
+        enabled={boolean}
+      >
+        {(query) => <>{query.data.pages.filter(({ text }) => text)}</>}
+      </SuspenseInfiniteQuery>
+    )
+    ;() => (
+      <SuspenseInfiniteQuery
+        queryKey={queryKey}
+        queryFn={queryFn}
+        //@ts-expect-error no placeholderData
+        placeholderData="placeholder"
+      >
+        {(query) => <>{query.data.pages.filter(({ text }) => text)}</>}
+      </SuspenseInfiniteQuery>
+    )
+    ;() => (
+      <SuspenseInfiniteQuery
+        queryKey={queryKey}
+        queryFn={queryFn}
+        //@ts-expect-error no placeholderData
+        placeholderData="placeholder"
+      >
+        {(query) => <>{query.data.pages.filter(({ text }) => text)}</>}
+      </SuspenseInfiniteQuery>
+    )
+  })
+
+  it('type check', () => {
+    ;() => (
+      <SuspenseInfiniteQuery queryKey={queryKey} queryFn={queryFn}>
+        {(query) => {
+          expectTypeOf(query).toEqualTypeOf<UseSuspenseInfiniteQueryResult<{ text: string }>>()
+          expectTypeOf(query.data).toEqualTypeOf<InfiniteData<{ text: string }>>()
+          expectTypeOf(query.status).toEqualTypeOf<'success'>()
+          return <></>
+        }}
+      </SuspenseInfiniteQuery>
+    )
+    ;() => (
+      <SuspenseInfiniteQuery
+        queryKey={queryKey}
+        queryFn={queryFn}
+        select={(data) => ({
+          pages: data.pages.map(({ text }) => text),
+          pageParams: data.pageParams,
+        })}
+      >
+        {(selectedQuery) => {
+          expectTypeOf(selectedQuery).toEqualTypeOf<UseSuspenseInfiniteQueryResult<string>>()
+          expectTypeOf(selectedQuery.data).toEqualTypeOf<InfiniteData<string>>()
+          expectTypeOf(selectedQuery.status).toEqualTypeOf<'success'>()
+          return <></>
+        }}
+      </SuspenseInfiniteQuery>
+    )
+
+    expectTypeOf(
+      <SuspenseInfiniteQuery queryKey={queryKey} queryFn={queryFn}>
+        {() => <></>}
+      </SuspenseInfiniteQuery>
+    ).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(
+      <SuspenseInfiniteQuery queryKey={queryKey} queryFn={queryFn}>
+        {() => <></>}
+      </SuspenseInfiniteQuery>
+    ).not.toEqualTypeOf<ReactNode>()
+  })
+})