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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Viva Republica, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/OmitKeyof-CFsZLI4k.d.cts

@@ -0,0 +1,3 @@
+type OmitKeyof<TObject, TKey extends TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject, TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
+
+export type { OmitKeyof as O };

package/dist/OmitKeyof-CFsZLI4k.d.ts

@@ -0,0 +1,3 @@
+type OmitKeyof<TObject, TKey extends TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject, TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
+
+export type { OmitKeyof as O };

package/dist/QueryErrorBoundary.cjs

@@ -0,0 +1,81 @@
+"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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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/QueryErrorBoundary.tsx
+var QueryErrorBoundary_exports = {};
+__export(QueryErrorBoundary_exports, {
+  QueryErrorBoundary: () => QueryErrorBoundary
+});
+module.exports = __toCommonJS(QueryErrorBoundary_exports);
+var import_react = require("@suspensive/react");
+var import_react_query = require("@tanstack/react-query");
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var QueryErrorBoundary = (0, import_react2.forwardRef)((_a, resetRef) => {
+  var _b = _a, { onReset } = _b, props = __objRest(_b, ["onReset"]);
+  const { reset } = (0, import_react_query.useQueryErrorResetBoundary)();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react.ErrorBoundary,
+    __spreadProps(__spreadValues({}, props), {
+      onReset: () => {
+        onReset == null ? void 0 : onReset();
+        reset();
+      },
+      ref: resetRef
+    })
+  );
+});
+if (process.env.NODE_ENV === "development") {
+  QueryErrorBoundary.displayName = "QueryErrorBoundary";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryErrorBoundary
+});
+//# sourceMappingURL=QueryErrorBoundary.cjs.map

package/dist/QueryErrorBoundary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/QueryErrorBoundary.tsx"],"sourcesContent":["import { ErrorBoundary } from '@suspensive/react'\nimport { useQueryErrorResetBoundary } from '@tanstack/react-query'\nimport { type ComponentPropsWithoutRef, type ComponentRef, forwardRef } from 'react'\n\n/**\n * 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\n * @see {@link https://suspensive.org/docs/react-query/QueryErrorBoundary}\n */\nexport const QueryErrorBoundary = forwardRef<\n  ComponentRef<typeof ErrorBoundary>,\n  ComponentPropsWithoutRef<typeof ErrorBoundary>\n>(({ onReset, ...props }, resetRef) => {\n  const { reset } = useQueryErrorResetBoundary()\n  return (\n    <ErrorBoundary\n      {...props}\n      onReset={() => {\n        onReset?.()\n        reset()\n      }}\n      ref={resetRef}\n    />\n  )\n})\nif (process.env.NODE_ENV === 'development') {\n  QueryErrorBoundary.displayName = 'QueryErrorBoundary'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA8B;AAC9B,yBAA2C;AAC3C,IAAAA,gBAA6E;AAYzE;AANG,IAAM,yBAAqB,0BAGhC,CAAC,IAAuB,aAAa;AAApC,eAAE,UAXL,IAWG,IAAc,kBAAd,IAAc,CAAZ;AACH,QAAM,EAAE,MAAM,QAAI,+CAA2B;AAC7C,SACE;AAAA,IAAC;AAAA,qCACK,QADL;AAAA,MAEC,SAAS,MAAM;AACb;AACA,cAAM;AAAA,MACR;AAAA,MACA,KAAK;AAAA;AAAA,EACP;AAEJ,CAAC;AACD,IAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,qBAAmB,cAAc;AACnC;","names":["import_react"]}

package/dist/QueryErrorBoundary.d.cts

@@ -0,0 +1,29 @@
+import * as _suspensive_react from '@suspensive/react';
+import * as react 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}
+ */
+declare const QueryErrorBoundary: react.ForwardRefExoticComponent<Omit<{
+    resetKeys?: unknown[] | undefined;
+    onReset?(): void;
+    onError?(error: Error, info: react.ErrorInfo): void;
+    fallback: react.ReactNode | react.FunctionComponent<_suspensive_react.ErrorBoundaryFallbackProps<Error>>;
+    shouldCatch?: (boolean | (new (...args: any[]) => Error) | ((error: Error) => boolean)) | [boolean | (new (...args: any[]) => Error) | ((error: Error) => boolean), ...(boolean | (new (...args: any[]) => Error) | ((error: Error) => boolean))[]] | undefined;
+} & {
+    children?: react.ReactNode;
+} & {
+    devMode?: {
+        showFallback?: boolean | {
+            errorMessage?: string | undefined;
+            after?: number | undefined;
+        } | undefined;
+    } | undefined;
+} & react.RefAttributes<{
+    reset(): void;
+}>, "ref"> & react.RefAttributes<{
+    reset(): void;
+}>>;
+
+export { QueryErrorBoundary };

package/dist/QueryErrorBoundary.d.ts

@@ -0,0 +1,29 @@
+import * as _suspensive_react from '@suspensive/react';
+import * as react 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}
+ */
+declare const QueryErrorBoundary: react.ForwardRefExoticComponent<Omit<{
+    resetKeys?: unknown[] | undefined;
+    onReset?(): void;
+    onError?(error: Error, info: react.ErrorInfo): void;
+    fallback: react.ReactNode | react.FunctionComponent<_suspensive_react.ErrorBoundaryFallbackProps<Error>>;
+    shouldCatch?: (boolean | (new (...args: any[]) => Error) | ((error: Error) => boolean)) | [boolean | (new (...args: any[]) => Error) | ((error: Error) => boolean), ...(boolean | (new (...args: any[]) => Error) | ((error: Error) => boolean))[]] | undefined;
+} & {
+    children?: react.ReactNode;
+} & {
+    devMode?: {
+        showFallback?: boolean | {
+            errorMessage?: string | undefined;
+            after?: number | undefined;
+        } | undefined;
+    } | undefined;
+} & react.RefAttributes<{
+    reset(): void;
+}>, "ref"> & react.RefAttributes<{
+    reset(): void;
+}>>;
+
+export { QueryErrorBoundary };

package/dist/QueryErrorBoundary.js

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

package/dist/QueryErrorBoundary.js.map

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

package/dist/SuspenseInfiniteQuery.cjs

@@ -0,0 +1,81 @@
+"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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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/SuspenseInfiniteQuery.tsx
+var SuspenseInfiniteQuery_exports = {};
+__export(SuspenseInfiniteQuery_exports, {
+  SuspenseInfiniteQuery: () => SuspenseInfiniteQuery
+});
+module.exports = __toCommonJS(SuspenseInfiniteQuery_exports);
+
+// src/useSuspenseInfiniteQuery.ts
+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
+  }));
+}
+
+// src/SuspenseInfiniteQuery.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var SuspenseInfiniteQuery = (_a) => {
+  var _b = _a, {
+    children
+  } = _b, options = __objRest(_b, [
+    "children"
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: children(useSuspenseInfiniteQuery(options)) });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SuspenseInfiniteQuery
+});
+//# sourceMappingURL=SuspenseInfiniteQuery.cjs.map

package/dist/SuspenseInfiniteQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/SuspenseInfiniteQuery.tsx","../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["import type { QueryKey } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport {\n  type UseSuspenseInfiniteQueryOptions,\n  type UseSuspenseInfiniteQueryResult,\n  useSuspenseInfiniteQuery,\n} from './useSuspenseInfiniteQuery'\n\n/**\n * @experimental This is experimental feature.\n */\nexport const SuspenseInfiniteQuery = <\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>({\n  children,\n  ...options\n}: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n  children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode\n}) => <>{children(useSuspenseInfiniteQuery(options))}</>\n","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;;;ACAA,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;;;ADzBM;AAVC,IAAM,wBAAwB,CAKnC,OAKC;AALD,eACA;AAAA;AAAA,EAjBF,IAgBE,IAEG,oBAFH,IAEG;AAAA,IADH;AAAA;AAII,oFAAG,mBAAS,yBAAyB,OAAO,CAAC,GAAE;AAAA;","names":[]}

package/dist/SuspenseInfiniteQuery.d.cts

@@ -0,0 +1,14 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { QueryKey } from '@tanstack/react-query';
+import { ReactNode } from 'react';
+import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from './useSuspenseInfiniteQuery.cjs';
+import './OmitKeyof-CFsZLI4k.cjs';
+
+/**
+ * @experimental This is experimental feature.
+ */
+declare const SuspenseInfiniteQuery: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ children, ...options }: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+export { SuspenseInfiniteQuery };

package/dist/SuspenseInfiniteQuery.d.ts

@@ -0,0 +1,14 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { QueryKey } from '@tanstack/react-query';
+import { ReactNode } from 'react';
+import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from './useSuspenseInfiniteQuery.js';
+import './OmitKeyof-CFsZLI4k.js';
+
+/**
+ * @experimental This is experimental feature.
+ */
+declare const SuspenseInfiniteQuery: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ children, ...options }: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    children: (query: UseSuspenseInfiniteQueryResult<TData, TError>) => ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+export { SuspenseInfiniteQuery };

package/dist/SuspenseInfiniteQuery.js

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

package/dist/SuspenseInfiniteQuery.js.map

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

package/dist/SuspenseQueries.cjs

@@ -0,0 +1,69 @@
+"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/SuspenseQueries.tsx
+var SuspenseQueries_exports = {};
+__export(SuspenseQueries_exports, {
+  SuspenseQueries: () => SuspenseQueries
+});
+module.exports = __toCommonJS(SuspenseQueries_exports);
+
+// src/useSuspenseQueries.ts
+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
+  });
+}
+
+// src/SuspenseQueries.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function SuspenseQueries({
+  children,
+  queries
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: children(useSuspenseQueries({ queries })) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SuspenseQueries
+});
+//# sourceMappingURL=SuspenseQueries.cjs.map

package/dist/SuspenseQueries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/SuspenseQueries.tsx","../src/useSuspenseQueries.ts"],"sourcesContent":["import type { ReactNode } from 'react'\nimport { type SuspenseQueriesOptions, type SuspenseQueriesResults, useSuspenseQueries } from './useSuspenseQueries'\n\n/**\n * @experimental This is experimental feature.\n */\nexport function SuspenseQueries<T extends any[]>({\n  children,\n  queries,\n}: {\n  queries: readonly [...SuspenseQueriesOptions<T>]\n  children: (queries: SuspenseQueriesResults<T>) => ReactNode\n}) {\n  return <>{children(useSuspenseQueries({ queries }))}</>\n}\n","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;;;ACAA,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;;;ADjHS;AAPF,SAAS,gBAAiC;AAAA,EAC/C;AAAA,EACA;AACF,GAGG;AACD,SAAO,2EAAG,mBAAS,mBAAmB,EAAE,QAAQ,CAAC,CAAC,GAAE;AACtD;","names":[]}

package/dist/SuspenseQueries.d.cts

@@ -0,0 +1,16 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { SuspenseQueriesOptions, SuspenseQueriesResults } from './useSuspenseQueries.cjs';
+import '@tanstack/react-query';
+import './useSuspenseQuery.cjs';
+import './OmitKeyof-CFsZLI4k.cjs';
+
+/**
+ * @experimental This is experimental feature.
+ */
+declare function SuspenseQueries<T extends any[]>({ children, queries, }: {
+    queries: readonly [...SuspenseQueriesOptions<T>];
+    children: (queries: SuspenseQueriesResults<T>) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+export { SuspenseQueries };

package/dist/SuspenseQueries.d.ts

@@ -0,0 +1,16 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { SuspenseQueriesOptions, SuspenseQueriesResults } from './useSuspenseQueries.js';
+import '@tanstack/react-query';
+import './useSuspenseQuery.js';
+import './OmitKeyof-CFsZLI4k.js';
+
+/**
+ * @experimental This is experimental feature.
+ */
+declare function SuspenseQueries<T extends any[]>({ children, queries, }: {
+    queries: readonly [...SuspenseQueriesOptions<T>];
+    children: (queries: SuspenseQueriesResults<T>) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+export { SuspenseQueries };

package/dist/SuspenseQueries.js

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

package/dist/SuspenseQueries.js.map

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

package/dist/SuspenseQuery.cjs

@@ -0,0 +1,81 @@
+"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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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/SuspenseQuery.tsx
+var SuspenseQuery_exports = {};
+__export(SuspenseQuery_exports, {
+  SuspenseQuery: () => SuspenseQuery
+});
+module.exports = __toCommonJS(SuspenseQuery_exports);
+
+// src/useSuspenseQuery.ts
+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
+  }));
+}
+
+// src/SuspenseQuery.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var SuspenseQuery = (_a) => {
+  var _b = _a, {
+    children
+  } = _b, options = __objRest(_b, [
+    "children"
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: children(useSuspenseQuery(options)) });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SuspenseQuery
+});
+//# sourceMappingURL=SuspenseQuery.cjs.map

package/dist/SuspenseQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/SuspenseQuery.tsx","../src/useSuspenseQuery.ts"],"sourcesContent":["import type { QueryKey } from '@tanstack/react-query'\nimport type { ReactNode } from 'react'\nimport { type UseSuspenseQueryOptions, type UseSuspenseQueryResult, useSuspenseQuery } from './useSuspenseQuery'\n\n/**\n * @experimental This is experimental feature.\n */\nexport const SuspenseQuery = <\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>({\n  children,\n  ...options\n}: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n  children: (queryResult: UseSuspenseQueryResult<TData, TError>) => ReactNode\n}) => <>{children(useSuspenseQuery(options))}</>\n","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;;;ACAA,yBAAmF;AAuB5E,SAAS,iBAKd,SAA0E;AAC1E,aAAO,6BAAiD,iCACnD,UADmD;AAAA,IAEtD,SAAS;AAAA,IACT,kBAAkB;AAAA,IAClB,UAAU;AAAA,EACZ,EAAC;AACH;;;ADlBM;AAVC,IAAM,gBAAgB,CAK3B,OAKC;AALD,eACA;AAAA;AAAA,EAbF,IAYE,IAEG,oBAFH,IAEG;AAAA,IADH;AAAA;AAII,oFAAG,mBAAS,iBAAiB,OAAO,CAAC,GAAE;AAAA;","names":[]}

package/dist/SuspenseQuery.d.cts

@@ -0,0 +1,14 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { QueryKey } from '@tanstack/react-query';
+import { ReactNode } from 'react';
+import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery.cjs';
+import './OmitKeyof-CFsZLI4k.cjs';
+
+/**
+ * @experimental This is experimental feature.
+ */
+declare const SuspenseQuery: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ children, ...options }: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    children: (queryResult: UseSuspenseQueryResult<TData, TError>) => ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+export { SuspenseQuery };

package/dist/SuspenseQuery.d.ts

@@ -0,0 +1,14 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { QueryKey } from '@tanstack/react-query';
+import { ReactNode } from 'react';
+import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './useSuspenseQuery.js';
+import './OmitKeyof-CFsZLI4k.js';
+
+/**
+ * @experimental This is experimental feature.
+ */
+declare const SuspenseQuery: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ children, ...options }: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    children: (queryResult: UseSuspenseQueryResult<TData, TError>) => ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+export { SuspenseQuery };

package/dist/SuspenseQuery.js

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

package/dist/SuspenseQuery.js.map

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

package/dist/chunk-3B63MBHY.js

@@ -0,0 +1,22 @@
+"use client"
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-QETBZSG5.js";
+
+// src/useSuspenseInfiniteQuery.ts
+import {
+  useInfiniteQuery
+} from "@tanstack/react-query";
+function useSuspenseInfiniteQuery(options) {
+  return useInfiniteQuery(__spreadProps(__spreadValues({}, options), {
+    enabled: true,
+    suspense: true,
+    useErrorBoundary: true
+  }));
+}
+
+export {
+  useSuspenseInfiniteQuery
+};
+//# sourceMappingURL=chunk-3B63MBHY.js.map

package/dist/chunk-3B63MBHY.js.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,EAKE;AAAA,OACK;AA0BA,SAAS,yBAMd,SAC+C;AAC/C,SAAO,iBAAiB,iCACnB,UADmB;AAAA,IAEtB,SAAS;AAAA,IACT,UAAU;AAAA,IACV,kBAAkB;AAAA,EACpB,EAAC;AACH;","names":[]}