@tanstack/preact-query 5.102.3 → 5.102.4

package/build/modern/HydrationBoundary.d.ts

@@ -1,14 +1,75 @@
 import { DehydratedState, HydrateOptions, OmitKeyof, QueryClient } from "@tanstack/query-core";
 import { ComponentChildren } from "preact";
 //#region src/HydrationBoundary.d.ts
+/**
+ * The props accepted by `HydrationBoundary`.
+ */
 interface HydrationBoundaryProps {
+  /**
+   * The state to hydrate.
+   */
   state: DehydratedState | null | undefined;
+  /**
+   * Optional. Note: unlike `hydrate`, `mutations` cannot be set here.
+   */
   options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
     defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
   };
+  /**
+   * The components to render — always rendered unconditionally, not gated on hydration. New queries are
+   * hydrated into the cache during render; for queries that already exist in the cache, only newer dehydrated
+   * data is hydrated, and that happens in an effect after commit, so `children` may render briefly before it
+   * lands.
+   */
   children?: ComponentChildren;
+  /**
+   * Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will be used.
+   */
   queryClient?: QueryClient;
 }
+/**
+ * `HydrationBoundary` adds a previously dehydrated state into the `queryClient` that would be returned by
+ * `useQueryClient()`. If the client already contains data, the new queries will be intelligently merged based on
+ * update timestamp.
+ *
+ * Note: Only `queries` can be dehydrated with an `HydrationBoundary`.
+ *
+ * @returns The provided `children`, rendered unconditionally. New queries in `state` are hydrated into the
+ * cache during render; for queries already in the cache, only newer dehydrated data is hydrated, in an effect
+ * after commit.
+ *
+ * @example
+ * ```tsx
+ * import { HydrationBoundary } from '@tanstack/preact-query'
+ *
+ * function App() {
+ *   return <HydrationBoundary state={dehydratedState}>...</HydrationBoundary>
+ * }
+ * ```
+ *
+ * @example
+ * Server-side prefetch handed off to the client via `dehydrate`:
+ * ```tsx
+ * import { HydrationBoundary, dehydrate, noop } from '@tanstack/preact-query'
+ *
+ * async function ServerComponent() {
+ *   const queryClient = getQueryClient()
+ *
+ *   await queryClient
+ *     .query({
+ *       queryKey: ['posts'],
+ *       queryFn: fetchPosts,
+ *     })
+ *     .catch(noop)
+ *
+ *   return (
+ *     <HydrationBoundary state={dehydrate(queryClient)}>
+ *       <Posts />
+ *     </HydrationBoundary>
+ *   )
+ * }
+ * ```
+ */
 declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
 //#endregion
 export { HydrationBoundary, HydrationBoundaryProps };

package/build/modern/HydrationBoundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;UAaiB;EACf,OAAO;EACP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;EAIZ,WAAW;EACX,cAAc;;cAGH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
+{"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;UAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}

package/build/modern/HydrationBoundary.js

@@ -4,6 +4,49 @@ import { Fragment } from "preact";
 import { useEffect, useMemo, useRef } from "preact/hooks";
 import { jsx } from "preact/jsx-runtime";
 //#region src/HydrationBoundary.tsx
+/**
+* `HydrationBoundary` adds a previously dehydrated state into the `queryClient` that would be returned by
+* `useQueryClient()`. If the client already contains data, the new queries will be intelligently merged based on
+* update timestamp.
+*
+* Note: Only `queries` can be dehydrated with an `HydrationBoundary`.
+*
+* @returns The provided `children`, rendered unconditionally. New queries in `state` are hydrated into the
+* cache during render; for queries already in the cache, only newer dehydrated data is hydrated, in an effect
+* after commit.
+*
+* @example
+* ```tsx
+* import { HydrationBoundary } from '@tanstack/preact-query'
+*
+* function App() {
+*   return <HydrationBoundary state={dehydratedState}>...</HydrationBoundary>
+* }
+* ```
+*
+* @example
+* Server-side prefetch handed off to the client via `dehydrate`:
+* ```tsx
+* import { HydrationBoundary, dehydrate, noop } from '@tanstack/preact-query'
+*
+* async function ServerComponent() {
+*   const queryClient = getQueryClient()
+*
+*   await queryClient
+*     .query({
+*       queryKey: ['posts'],
+*       queryFn: fetchPosts,
+*     })
+*     .catch(noop)
+*
+*   return (
+*     <HydrationBoundary state={dehydrate(queryClient)}>
+*       <Posts />
+*     </HydrationBoundary>
+*   )
+* }
+* ```
+*/
 const HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
 	const client = useQueryClient(queryClient);
 	const optionsRef = useRef(options);

package/build/modern/HydrationBoundary.js.map

@@ -1 +1 @@
-{"version":3,"file":"HydrationBoundary.js","names":[],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["import { hydrate } from '@tanstack/query-core'\nimport type {\n  DehydratedState,\n  HydrateOptions,\n  OmitKeyof,\n  QueryClient,\n} from '@tanstack/query-core'\nimport { Fragment } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport { useEffect, useMemo, useRef } from 'preact/hooks'\n\nimport { useQueryClient } from './QueryClientProvider'\n\nexport interface HydrationBoundaryProps {\n  state: DehydratedState | null | undefined\n  options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n    defaultOptions?: OmitKeyof<\n      Exclude<HydrateOptions['defaultOptions'], undefined>,\n      'mutations'\n    >\n  }\n  children?: ComponentChildren\n  queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n  children,\n  options = {},\n  state,\n  queryClient,\n}: HydrationBoundaryProps) => {\n  const client = useQueryClient(queryClient)\n\n  const optionsRef = useRef(options)\n  useEffect(() => {\n    optionsRef.current = options\n  })\n\n  // This useMemo is for performance reasons only, everything inside it must\n  // be safe to run in every render and code here should be read as \"in render\".\n  //\n  // This code needs to happen during the render phase, because after initial\n  // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n  // during a transition, we want to hydrate as much as is safe in render so\n  // we can prerender as much as possible.\n  //\n  // For any queries that already exist in the cache, we want to hold back on\n  // hydrating until _after_ the render phase. The reason for this is that during\n  // transitions, we don't want the existing queries and observers to update to\n  // the new data on the current page, only _after_ the transition is committed.\n  // If the transition is aborted, we will have hydrated any _new_ queries, but\n  // we throw away the fresh data for any existing ones to avoid unexpectedly\n  // updating the UI.\n  const hydrationQueue: DehydratedState['queries'] | undefined = useMemo(() => {\n    if (state) {\n      if (typeof state !== 'object') {\n        return\n      }\n\n      const queryCache = client.getQueryCache()\n      // State is supplied from the outside and we might as well fail\n      // gracefully if it has the wrong shape, so while we type `queries`\n      // as required, we still provide a fallback.\n      const queries = state.queries || []\n\n      const newQueries: DehydratedState['queries'] = []\n      const existingQueries: DehydratedState['queries'] = []\n      for (const dehydratedQuery of queries) {\n        const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n        if (!existingQuery) {\n          newQueries.push(dehydratedQuery)\n        } else {\n          const hydrationIsNewer =\n            dehydratedQuery.state.dataUpdatedAt >\n              existingQuery.state.dataUpdatedAt ||\n            (dehydratedQuery.promise &&\n              existingQuery.state.status !== 'pending' &&\n              existingQuery.state.fetchStatus !== 'fetching' &&\n              dehydratedQuery.dehydratedAt !== undefined &&\n              dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt)\n\n          if (hydrationIsNewer) {\n            existingQueries.push(dehydratedQuery)\n          }\n        }\n      }\n\n      if (newQueries.length > 0) {\n        // It's actually fine to call this with queries/state that already exists\n        // in the cache, or is older. hydrate() is idempotent for queries.\n        hydrate(client, { queries: newQueries }, optionsRef.current)\n      }\n      if (existingQueries.length > 0) {\n        return existingQueries\n      }\n    }\n    return undefined\n  }, [client, state])\n\n  useEffect(() => {\n    if (hydrationQueue) {\n      hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n    }\n  }, [client, hydrationQueue])\n\n  return <Fragment>{children}</Fragment>\n}\n"],"mappings":";;;;;;AAyBA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAAS,eAAe,WAAW;CAEzC,MAAM,aAAa,OAAO,OAAO;CACjC,gBAAgB;EACd,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,iBAAyD,cAAc;EAC3E,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAIxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAW/B,IARE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eAAe,cAAc,MAAM,eAGrD,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAGtB,QAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAElB,gBAAgB;EACd,IAAI,gBACF,QAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO,oBAAC,UAAD,EAAW,SAAmB,CAAA;AACvC"}
+{"version":3,"file":"HydrationBoundary.js","names":[],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["import { hydrate } from '@tanstack/query-core'\nimport type {\n  DehydratedState,\n  HydrateOptions,\n  OmitKeyof,\n  QueryClient,\n} from '@tanstack/query-core'\nimport { Fragment } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport { useEffect, useMemo, useRef } from 'preact/hooks'\n\nimport { useQueryClient } from './QueryClientProvider'\n\n/**\n * The props accepted by `HydrationBoundary`.\n */\nexport interface HydrationBoundaryProps {\n  /**\n   * The state to hydrate.\n   */\n  state: DehydratedState | null | undefined\n  /**\n   * Optional. Note: unlike `hydrate`, `mutations` cannot be set here.\n   */\n  options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n    defaultOptions?: OmitKeyof<\n      Exclude<HydrateOptions['defaultOptions'], undefined>,\n      'mutations'\n    >\n  }\n  /**\n   * The components to render — always rendered unconditionally, not gated on hydration. New queries are\n   * hydrated into the cache during render; for queries that already exist in the cache, only newer dehydrated\n   * data is hydrated, and that happens in an effect after commit, so `children` may render briefly before it\n   * lands.\n   */\n  children?: ComponentChildren\n  /**\n   * Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will be used.\n   */\n  queryClient?: QueryClient\n}\n\n/**\n * `HydrationBoundary` adds a previously dehydrated state into the `queryClient` that would be returned by\n * `useQueryClient()`. If the client already contains data, the new queries will be intelligently merged based on\n * update timestamp.\n *\n * Note: Only `queries` can be dehydrated with an `HydrationBoundary`.\n *\n * @returns The provided `children`, rendered unconditionally. New queries in `state` are hydrated into the\n * cache during render; for queries already in the cache, only newer dehydrated data is hydrated, in an effect\n * after commit.\n *\n * @example\n * ```tsx\n * import { HydrationBoundary } from '@tanstack/preact-query'\n *\n * function App() {\n *   return <HydrationBoundary state={dehydratedState}>...</HydrationBoundary>\n * }\n * ```\n *\n * @example\n * Server-side prefetch handed off to the client via `dehydrate`:\n * ```tsx\n * import { HydrationBoundary, dehydrate, noop } from '@tanstack/preact-query'\n *\n * async function ServerComponent() {\n *   const queryClient = getQueryClient()\n *\n *   await queryClient\n *     .query({\n *       queryKey: ['posts'],\n *       queryFn: fetchPosts,\n *     })\n *     .catch(noop)\n *\n *   return (\n *     <HydrationBoundary state={dehydrate(queryClient)}>\n *       <Posts />\n *     </HydrationBoundary>\n *   )\n * }\n * ```\n */\nexport const HydrationBoundary = ({\n  children,\n  options = {},\n  state,\n  queryClient,\n}: HydrationBoundaryProps) => {\n  const client = useQueryClient(queryClient)\n\n  const optionsRef = useRef(options)\n  useEffect(() => {\n    optionsRef.current = options\n  })\n\n  // This useMemo is for performance reasons only, everything inside it must\n  // be safe to run in every render and code here should be read as \"in render\".\n  //\n  // This code needs to happen during the render phase, because after initial\n  // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n  // during a transition, we want to hydrate as much as is safe in render so\n  // we can prerender as much as possible.\n  //\n  // For any queries that already exist in the cache, we want to hold back on\n  // hydrating until _after_ the render phase. The reason for this is that during\n  // transitions, we don't want the existing queries and observers to update to\n  // the new data on the current page, only _after_ the transition is committed.\n  // If the transition is aborted, we will have hydrated any _new_ queries, but\n  // we throw away the fresh data for any existing ones to avoid unexpectedly\n  // updating the UI.\n  const hydrationQueue: DehydratedState['queries'] | undefined = useMemo(() => {\n    if (state) {\n      if (typeof state !== 'object') {\n        return\n      }\n\n      const queryCache = client.getQueryCache()\n      // State is supplied from the outside and we might as well fail\n      // gracefully if it has the wrong shape, so while we type `queries`\n      // as required, we still provide a fallback.\n      const queries = state.queries || []\n\n      const newQueries: DehydratedState['queries'] = []\n      const existingQueries: DehydratedState['queries'] = []\n      for (const dehydratedQuery of queries) {\n        const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n        if (!existingQuery) {\n          newQueries.push(dehydratedQuery)\n        } else {\n          const hydrationIsNewer =\n            dehydratedQuery.state.dataUpdatedAt >\n              existingQuery.state.dataUpdatedAt ||\n            (dehydratedQuery.promise &&\n              existingQuery.state.status !== 'pending' &&\n              existingQuery.state.fetchStatus !== 'fetching' &&\n              dehydratedQuery.dehydratedAt !== undefined &&\n              dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt)\n\n          if (hydrationIsNewer) {\n            existingQueries.push(dehydratedQuery)\n          }\n        }\n      }\n\n      if (newQueries.length > 0) {\n        // It's actually fine to call this with queries/state that already exists\n        // in the cache, or is older. hydrate() is idempotent for queries.\n        hydrate(client, { queries: newQueries }, optionsRef.current)\n      }\n      if (existingQueries.length > 0) {\n        return existingQueries\n      }\n    }\n    return undefined\n  }, [client, state])\n\n  useEffect(() => {\n    if (hydrationQueue) {\n      hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n    }\n  }, [client, hydrationQueue])\n\n  return <Fragment>{children}</Fragment>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAAS,eAAe,WAAW;CAEzC,MAAM,aAAa,OAAO,OAAO;CACjC,gBAAgB;EACd,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,iBAAyD,cAAc;EAC3E,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAIxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAW/B,IARE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eAAe,cAAc,MAAM,eAGrD,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAGtB,QAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAElB,gBAAgB;EACd,IAAI,gBACF,QAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO,oBAAC,UAAD,EAAW,SAAmB,CAAA;AACvC"}

package/build/modern/IsRestoringProvider.cjs

@@ -3,7 +3,18 @@ let preact = require("preact");
 let preact_hooks = require("preact/hooks");
 //#region src/IsRestoringProvider.ts
 const IsRestoringContext = (0, preact.createContext)(false);
+/**
+* If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to
+* check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid
+* race conditions between the restore and mounting queries.
+*
+* @returns `true` while a persisted client is being restored, `false` otherwise.
+*/
 const useIsRestoring = () => (0, preact_hooks.useContext)(IsRestoringContext);
+/**
+* The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
+* being restored, read by `useIsRestoring`.
+*/
 const IsRestoringProvider = IsRestoringContext.Provider;
 //#endregion
 exports.IsRestoringProvider = IsRestoringProvider;

package/build/modern/IsRestoringProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"IsRestoringProvider.cjs","names":["createContext","useContext"],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["import { createContext } from 'preact'\nimport { useContext } from 'preact/hooks'\n\nconst IsRestoringContext = createContext(false)\n\nexport const useIsRestoring = () => useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;;AAGA,MAAM,sBAAA,GAAqBA,OAAAA,cAAAA,CAAc,KAAK;AAE9C,MAAa,wBAAA,GAAuBC,aAAAA,WAAAA,CAAW,kBAAkB;AACjE,MAAa,sBAAsB,mBAAmB"}
+{"version":3,"file":"IsRestoringProvider.cjs","names":["createContext","useContext"],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["import { createContext } from 'preact'\nimport { useContext } from 'preact/hooks'\n\nconst IsRestoringContext = createContext(false)\n\n/**\n * If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to\n * check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid\n * race conditions between the restore and mounting queries.\n *\n * @returns `true` while a persisted client is being restored, `false` otherwise.\n */\nexport const useIsRestoring = () => useContext(IsRestoringContext)\n\n/**\n * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently\n * being restored, read by `useIsRestoring`.\n */\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;;AAGA,MAAM,sBAAA,GAAqBA,OAAAA,cAAAA,CAAc,KAAK;;;;;;;;AAS9C,MAAa,wBAAA,GAAuBC,aAAAA,WAAAA,CAAW,kBAAkB;;;;;AAMjE,MAAa,sBAAsB,mBAAmB"}

package/build/modern/IsRestoringProvider.d.cts

@@ -1,5 +1,16 @@
 //#region src/IsRestoringProvider.d.ts
+/**
+ * If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to
+ * check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid
+ * race conditions between the restore and mounting queries.
+ *
+ * @returns `true` while a persisted client is being restored, `false` otherwise.
+ */
 declare const useIsRestoring: () => boolean;
+/**
+ * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
+ * being restored, read by `useIsRestoring`.
+ */
 declare const IsRestoringProvider: import("preact").Provider<boolean>;
 //#endregion
 export { IsRestoringProvider, useIsRestoring };

package/build/modern/IsRestoringProvider.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";cAKa;cACA,sCAAmB"}
+{"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;cAYa;;;;;cAMA,sCAAmB"}

package/build/modern/IsRestoringProvider.d.ts

@@ -1,5 +1,16 @@
 //#region src/IsRestoringProvider.d.ts
+/**
+ * If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to
+ * check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid
+ * race conditions between the restore and mounting queries.
+ *
+ * @returns `true` while a persisted client is being restored, `false` otherwise.
+ */
 declare const useIsRestoring: () => boolean;
+/**
+ * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
+ * being restored, read by `useIsRestoring`.
+ */
 declare const IsRestoringProvider: import("preact").Provider<boolean>;
 //#endregion
 export { IsRestoringProvider, useIsRestoring };

package/build/modern/IsRestoringProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";cAKa;cACA,sCAAmB"}
+{"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;cAYa;;;;;cAMA,sCAAmB"}

package/build/modern/IsRestoringProvider.js

@@ -2,7 +2,18 @@ import { createContext } from "preact";
 import { useContext } from "preact/hooks";
 //#region src/IsRestoringProvider.ts
 const IsRestoringContext = createContext(false);
+/**
+* If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to
+* check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid
+* race conditions between the restore and mounting queries.
+*
+* @returns `true` while a persisted client is being restored, `false` otherwise.
+*/
 const useIsRestoring = () => useContext(IsRestoringContext);
+/**
+* The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
+* being restored, read by `useIsRestoring`.
+*/
 const IsRestoringProvider = IsRestoringContext.Provider;
 //#endregion
 export { IsRestoringProvider, useIsRestoring };

package/build/modern/IsRestoringProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"IsRestoringProvider.js","names":[],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["import { createContext } from 'preact'\nimport { useContext } from 'preact/hooks'\n\nconst IsRestoringContext = createContext(false)\n\nexport const useIsRestoring = () => useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;AAGA,MAAM,qBAAqB,cAAc,KAAK;AAE9C,MAAa,uBAAuB,WAAW,kBAAkB;AACjE,MAAa,sBAAsB,mBAAmB"}
+{"version":3,"file":"IsRestoringProvider.js","names":[],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["import { createContext } from 'preact'\nimport { useContext } from 'preact/hooks'\n\nconst IsRestoringContext = createContext(false)\n\n/**\n * If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to\n * check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid\n * race conditions between the restore and mounting queries.\n *\n * @returns `true` while a persisted client is being restored, `false` otherwise.\n */\nexport const useIsRestoring = () => useContext(IsRestoringContext)\n\n/**\n * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently\n * being restored, read by `useIsRestoring`.\n */\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;AAGA,MAAM,qBAAqB,cAAc,KAAK;;;;;;;;AAS9C,MAAa,uBAAuB,WAAW,kBAAkB;;;;;AAMjE,MAAa,sBAAsB,mBAAmB"}

package/build/modern/QueryClientProvider.cjs

@@ -3,13 +3,43 @@ let preact = require("preact");
 let preact_hooks = require("preact/hooks");
 let preact_jsx_runtime = require("preact/jsx-runtime");
 //#region src/QueryClientProvider.tsx
+/**
+* The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
+*/
 const QueryClientContext = (0, preact.createContext)(void 0);
+/**
+* The `useQueryClient` hook returns the current `QueryClient` instance.
+*
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns The current `QueryClient` instance.
+* @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
+*/
 const useQueryClient = (queryClient) => {
 	const client = (0, preact_hooks.useContext)(QueryClientContext);
 	if (queryClient) return queryClient;
 	if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
 	return client;
 };
+/**
+* Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also
+* calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to
+* focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or
+* comes back online).
+*
+* @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.
+*
+* @example
+* ```tsx
+* import { QueryClient, QueryClientProvider } from '@tanstack/preact-query'
+*
+* const queryClient = new QueryClient()
+*
+* function App() {
+*   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>
+* }
+* ```
+*/
 const QueryClientProvider = ({ client, children }) => {
 	(0, preact_hooks.useEffect)(() => {
 		client.mount();

package/build/modern/QueryClientProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"QueryClientProvider.cjs","names":["createContext","useContext"],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core'\nimport { createContext } from 'preact'\nimport type { ComponentChildren, VNode } from 'preact'\nimport { useContext, useEffect } from 'preact/hooks'\n\nexport const QueryClientContext = createContext<QueryClient | undefined>(\n  undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\nexport type QueryClientProviderProps = {\n  client: QueryClient\n  children?: ComponentChildren\n}\n\nexport const QueryClientProvider = ({\n  client,\n  children,\n}: QueryClientProviderProps): VNode => {\n  useEffect(() => {\n    client.mount()\n    return () => {\n      client.unmount()\n    }\n  }, [client])\n\n  return (\n    <QueryClientContext.Provider value={client}>\n      {children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"mappings":";;;;;AAKA,MAAa,sBAAA,GAAqBA,OAAAA,cAAAA,CAChC,KAAA,CACF;AAEA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,UAAA,GAASC,aAAAA,WAAAA,CAAW,kBAAkB;CAE5C,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;AAOA,MAAa,uBAAuB,EAClC,QACA,eACqC;CACrC,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,iBAAA,GAAA,mBAAA,IAAA,CAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}
+{"version":3,"file":"QueryClientProvider.cjs","names":["createContext","useContext"],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core'\nimport { createContext } from 'preact'\nimport type { ComponentChildren, VNode } from 'preact'\nimport { useContext, useEffect } from 'preact/hooks'\n\n/**\n * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.\n */\nexport const QueryClientContext = createContext<QueryClient | undefined>(\n  undefined,\n)\n\n/**\n * The `useQueryClient` hook returns the current `QueryClient` instance.\n *\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns The current `QueryClient` instance.\n * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.\n */\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\n/**\n * The props accepted by `QueryClientProvider`.\n */\nexport type QueryClientProviderProps = {\n  /**\n   * **Required**\n   *\n   * The `QueryClient` instance to provide.\n   */\n  client: QueryClient\n  /**\n   * The components that get access to the provided `QueryClient`.\n   */\n  children?: ComponentChildren\n}\n\n/**\n * Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also\n * calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to\n * focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or\n * comes back online).\n *\n * @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.\n *\n * @example\n * ```tsx\n * import { QueryClient, QueryClientProvider } from '@tanstack/preact-query'\n *\n * const queryClient = new QueryClient()\n *\n * function App() {\n *   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>\n * }\n * ```\n */\nexport const QueryClientProvider = ({\n  client,\n  children,\n}: QueryClientProviderProps): VNode => {\n  useEffect(() => {\n    client.mount()\n    return () => {\n      client.unmount()\n    }\n  }, [client])\n\n  return (\n    <QueryClientContext.Provider value={client}>\n      {children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"mappings":";;;;;;;;AAQA,MAAa,sBAAA,GAAqBA,OAAAA,cAAAA,CAChC,KAAA,CACF;;;;;;;;;AAUA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,UAAA,GAASC,aAAAA,WAAAA,CAAW,kBAAkB;CAE5C,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,uBAAuB,EAClC,QACA,eACqC;CACrC,CAAA,GAAA,aAAA,UAAA,OAAgB;EACd,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,iBAAA,GAAA,mBAAA,IAAA,CAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}

package/build/modern/QueryClientProvider.d.cts

@@ -1,12 +1,53 @@
 import { QueryClient } from "@tanstack/query-core";
 import { ComponentChildren, VNode } from "preact";
 //#region src/QueryClientProvider.d.ts
+/**
+ * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
+ */
 declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
+/**
+ * The `useQueryClient` hook returns the current `QueryClient` instance.
+ *
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns The current `QueryClient` instance.
+ * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
+ */
 declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+/**
+ * The props accepted by `QueryClientProvider`.
+ */
 type QueryClientProviderProps = {
+  /**
+   * **Required**
+   *
+   * The `QueryClient` instance to provide.
+   */
   client: QueryClient;
+  /**
+   * The components that get access to the provided `QueryClient`.
+   */
   children?: ComponentChildren;
 };
+/**
+ * Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also
+ * calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to
+ * focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or
+ * comes back online).
+ *
+ * @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.
+ *
+ * @example
+ * ```tsx
+ * import { QueryClient, QueryClientProvider } from '@tanstack/preact-query'
+ *
+ * const queryClient = new QueryClient()
+ *
+ * function App() {
+ *   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>
+ * }
+ * ```
+ */
 declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
 //#endregion
 export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };

package/build/modern/QueryClientProvider.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;cAKa,qCAAkB,QAAA;cAIlB,iBAAkB,cAAc,gBAAW;KAc5C;EACV,QAAQ;EACR,WAAW;;cAGA,wBAAuB,QAAA,YAGjC,6BAA2B"}
+{"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;cAQa,qCAAkB,QAAA;;;;;;;;;cAYlB,iBAAkB,cAAc,gBAAW;;;;KAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;cAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}

package/build/modern/QueryClientProvider.d.ts

@@ -1,12 +1,53 @@
 import { QueryClient } from "@tanstack/query-core";
 import { ComponentChildren, VNode } from "preact";
 //#region src/QueryClientProvider.d.ts
+/**
+ * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
+ */
 declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
+/**
+ * The `useQueryClient` hook returns the current `QueryClient` instance.
+ *
+ * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+ * be used.
+ * @returns The current `QueryClient` instance.
+ * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
+ */
 declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+/**
+ * The props accepted by `QueryClientProvider`.
+ */
 type QueryClientProviderProps = {
+  /**
+   * **Required**
+   *
+   * The `QueryClient` instance to provide.
+   */
   client: QueryClient;
+  /**
+   * The components that get access to the provided `QueryClient`.
+   */
   children?: ComponentChildren;
 };
+/**
+ * Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also
+ * calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to
+ * focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or
+ * comes back online).
+ *
+ * @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.
+ *
+ * @example
+ * ```tsx
+ * import { QueryClient, QueryClientProvider } from '@tanstack/preact-query'
+ *
+ * const queryClient = new QueryClient()
+ *
+ * function App() {
+ *   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>
+ * }
+ * ```
+ */
 declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
 //#endregion
 export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };

package/build/modern/QueryClientProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;cAKa,qCAAkB,QAAA;cAIlB,iBAAkB,cAAc,gBAAW;KAc5C;EACV,QAAQ;EACR,WAAW;;cAGA,wBAAuB,QAAA,YAGjC,6BAA2B"}
+{"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;cAQa,qCAAkB,QAAA;;;;;;;;;cAYlB,iBAAkB,cAAc,gBAAW;;;;KAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;cAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}

package/build/modern/QueryClientProvider.js

@@ -2,13 +2,43 @@ import { createContext } from "preact";
 import { useContext, useEffect } from "preact/hooks";
 import { jsx } from "preact/jsx-runtime";
 //#region src/QueryClientProvider.tsx
+/**
+* The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
+*/
 const QueryClientContext = createContext(void 0);
+/**
+* The `useQueryClient` hook returns the current `QueryClient` instance.
+*
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns The current `QueryClient` instance.
+* @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
+*/
 const useQueryClient = (queryClient) => {
 	const client = useContext(QueryClientContext);
 	if (queryClient) return queryClient;
 	if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
 	return client;
 };
+/**
+* Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also
+* calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to
+* focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or
+* comes back online).
+*
+* @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.
+*
+* @example
+* ```tsx
+* import { QueryClient, QueryClientProvider } from '@tanstack/preact-query'
+*
+* const queryClient = new QueryClient()
+*
+* function App() {
+*   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>
+* }
+* ```
+*/
 const QueryClientProvider = ({ client, children }) => {
 	useEffect(() => {
 		client.mount();

package/build/modern/QueryClientProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"QueryClientProvider.js","names":[],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core'\nimport { createContext } from 'preact'\nimport type { ComponentChildren, VNode } from 'preact'\nimport { useContext, useEffect } from 'preact/hooks'\n\nexport const QueryClientContext = createContext<QueryClient | undefined>(\n  undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\nexport type QueryClientProviderProps = {\n  client: QueryClient\n  children?: ComponentChildren\n}\n\nexport const QueryClientProvider = ({\n  client,\n  children,\n}: QueryClientProviderProps): VNode => {\n  useEffect(() => {\n    client.mount()\n    return () => {\n      client.unmount()\n    }\n  }, [client])\n\n  return (\n    <QueryClientContext.Provider value={client}>\n      {children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,cAChC,KAAA,CACF;AAEA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,SAAS,WAAW,kBAAkB;CAE5C,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;AAOA,MAAa,uBAAuB,EAClC,QACA,eACqC;CACrC,gBAAgB;EACd,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,oBAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}
+{"version":3,"file":"QueryClientProvider.js","names":[],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core'\nimport { createContext } from 'preact'\nimport type { ComponentChildren, VNode } from 'preact'\nimport { useContext, useEffect } from 'preact/hooks'\n\n/**\n * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.\n */\nexport const QueryClientContext = createContext<QueryClient | undefined>(\n  undefined,\n)\n\n/**\n * The `useQueryClient` hook returns the current `QueryClient` instance.\n *\n * @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will\n * be used.\n * @returns The current `QueryClient` instance.\n * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.\n */\nexport const useQueryClient = (queryClient?: QueryClient) => {\n  const client = useContext(QueryClientContext)\n\n  if (queryClient) {\n    return queryClient\n  }\n\n  if (!client) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one')\n  }\n\n  return client\n}\n\n/**\n * The props accepted by `QueryClientProvider`.\n */\nexport type QueryClientProviderProps = {\n  /**\n   * **Required**\n   *\n   * The `QueryClient` instance to provide.\n   */\n  client: QueryClient\n  /**\n   * The components that get access to the provided `QueryClient`.\n   */\n  children?: ComponentChildren\n}\n\n/**\n * Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also\n * calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to\n * focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or\n * comes back online).\n *\n * @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.\n *\n * @example\n * ```tsx\n * import { QueryClient, QueryClientProvider } from '@tanstack/preact-query'\n *\n * const queryClient = new QueryClient()\n *\n * function App() {\n *   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>\n * }\n * ```\n */\nexport const QueryClientProvider = ({\n  client,\n  children,\n}: QueryClientProviderProps): VNode => {\n  useEffect(() => {\n    client.mount()\n    return () => {\n      client.unmount()\n    }\n  }, [client])\n\n  return (\n    <QueryClientContext.Provider value={client}>\n      {children}\n    </QueryClientContext.Provider>\n  )\n}\n"],"mappings":";;;;;;;AAQA,MAAa,qBAAqB,cAChC,KAAA,CACF;;;;;;;;;AAUA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,SAAS,WAAW,kBAAkB;CAE5C,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,uBAAuB,EAClC,QACA,eACqC;CACrC,gBAAgB;EACd,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,oBAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}

package/build/modern/QueryErrorResetBoundary.cjs

@@ -18,7 +18,82 @@ function createValue() {
 	};
 }
 const QueryErrorResetBoundaryContext = (0, preact.createContext)(createValue());
+/**
+* This hook will reset any query errors within the closest `QueryErrorResetBoundary`. If there is no boundary
+* defined it will reset them globally.
+*
+* @returns The boundary's {@link QueryErrorResetBoundaryValue}.
+*
+* @example
+* ```tsx
+* import { useErrorBoundary } from 'preact/hooks'
+* import type { ComponentChildren } from 'preact'
+* import { useQueryErrorResetBoundary } from '@tanstack/preact-query'
+*
+* function App({ children }: { children: ComponentChildren }) {
+*   const { reset } = useQueryErrorResetBoundary()
+*   const [error, resetError] = useErrorBoundary(() => reset())
+*
+*   if (error) {
+*     return (
+*       <div>
+*         There was an error!
+*         <button onClick={() => resetError()}>Try again</button>
+*       </div>
+*     )
+*   }
+*
+*   return children
+* }
+* ```
+*/
 const useQueryErrorResetBoundary = () => (0, preact_hooks.useContext)(QueryErrorResetBoundaryContext);
+/**
+* When using `suspense` or `throwOnError` in your queries, you need a way to let queries know that you want to
+* try again when re-rendering after some error occurred. With the `QueryErrorResetBoundary` component you can
+* reset any query errors within the boundaries of the component.
+*
+* @returns The `children`, rendered as-is, or called with the boundary's {@link QueryErrorResetBoundaryValue}
+* if `children` is a function.
+*
+* @example
+* ```tsx
+* import { useErrorBoundary } from 'preact/hooks'
+* import type { ComponentChildren } from 'preact'
+* import { QueryErrorResetBoundary } from '@tanstack/preact-query'
+*
+* function ErrorBoundary({
+*   children,
+*   reset,
+* }: {
+*   children: ComponentChildren
+*   reset: () => void
+* }) {
+*   const [error, resetError] = useErrorBoundary(() => reset())
+*
+*   if (error) {
+*     return (
+*       <div>
+*         There was an error!
+*         <button onClick={() => resetError()}>Try again</button>
+*       </div>
+*     )
+*   }
+*
+*   return children
+* }
+*
+* const App = () => (
+*   <QueryErrorResetBoundary>
+*     {({ reset }) => (
+*       <ErrorBoundary reset={reset}>
+*         <Page />
+*       </ErrorBoundary>
+*     )}
+*   </QueryErrorResetBoundary>
+* )
+* ```
+*/
 const QueryErrorResetBoundary = ({ children }) => {
 	const [value] = (0, preact_hooks.useState)(() => createValue());
 	return /* @__PURE__ */ (0, preact_jsx_runtime.jsx)(QueryErrorResetBoundaryContext.Provider, {

package/build/modern/QueryErrorResetBoundary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"QueryErrorResetBoundary.cjs","names":["createContext","useContext","useState"],"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["import { createContext } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport { useContext, useState } from 'preact/hooks'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n  clearReset: QueryErrorClearResetFunction\n  isReset: QueryErrorIsResetFunction\n  reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n  let isReset = false\n  return {\n    clearReset: () => {\n      isReset = false\n    },\n    reset: () => {\n      isReset = true\n    },\n    isReset: () => {\n      return isReset\n    },\n  }\n}\n\nconst QueryErrorResetBoundaryContext = createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n  useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n  value: QueryErrorResetBoundaryValue,\n) => ComponentChildren\n\nexport interface QueryErrorResetBoundaryProps {\n  children: QueryErrorResetBoundaryFunction | ComponentChildren\n}\n\nexport const QueryErrorResetBoundary = ({\n  children,\n}: QueryErrorResetBoundaryProps) => {\n  const [value] = useState(() => createValue())\n  return (\n    <QueryErrorResetBoundaryContext.Provider value={value}>\n      {typeof children === 'function' ? children(value) : children}\n    </QueryErrorResetBoundaryContext.Provider>\n  )\n}\n"],"mappings":";;;;;AAeA,SAAS,cAA4C;CACnD,IAAI,UAAU;CACd,OAAO;EACL,kBAAkB;GAChB,UAAU;EACZ;EACA,aAAa;GACX,UAAU;EACZ;EACA,eAAe;GACb,OAAO;EACT;CACF;AACF;AAEA,MAAM,kCAAA,GAAiCA,OAAAA,cAAAA,CAAc,YAAY,CAAC;AAIlE,MAAa,oCAAA,GACXC,aAAAA,WAAAA,CAAW,8BAA8B;AAY3C,MAAa,2BAA2B,EACtC,eACkC;CAClC,MAAM,CAAC,UAAA,GAASC,aAAAA,SAAAA,OAAe,YAAY,CAAC;CAC5C,OACE,iBAAA,GAAA,mBAAA,IAAA,CAAC,+BAA+B,UAAhC;EAAgD;EAC7C,UAAA,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;CACb,CAAA;AAE7C"}
+{"version":3,"file":"QueryErrorResetBoundary.cjs","names":["createContext","useContext","useState"],"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["import { createContext } from 'preact'\nimport type { ComponentChildren } from 'preact'\nimport { useContext, useState } from 'preact/hooks'\n\n// CONTEXT\n\n/**\n * Resets any query errors within the boundary, so queries know they can try again.\n */\nexport type QueryErrorResetFunction = () => void\n\n/**\n * Returns whether the boundary has been reset and not yet cleared.\n */\nexport type QueryErrorIsResetFunction = () => boolean\n\n/**\n * Clears the reset state, so queries know not to try again until the boundary is reset again.\n */\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n  /**\n   * Clears the reset state, so queries know not to try again until the boundary is reset again.\n   */\n  clearReset: QueryErrorClearResetFunction\n  /**\n   * Returns whether the boundary has been reset and not yet cleared.\n   */\n  isReset: QueryErrorIsResetFunction\n  /**\n   * Resets any query errors within the boundary, so queries know they can try again.\n   */\n  reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n  let isReset = false\n  return {\n    clearReset: () => {\n      isReset = false\n    },\n    reset: () => {\n      isReset = true\n    },\n    isReset: () => {\n      return isReset\n    },\n  }\n}\n\nconst QueryErrorResetBoundaryContext = createContext(createValue())\n\n// HOOK\n\n/**\n * This hook will reset any query errors within the closest `QueryErrorResetBoundary`. If there is no boundary\n * defined it will reset them globally.\n *\n * @returns The boundary's {@link QueryErrorResetBoundaryValue}.\n *\n * @example\n * ```tsx\n * import { useErrorBoundary } from 'preact/hooks'\n * import type { ComponentChildren } from 'preact'\n * import { useQueryErrorResetBoundary } from '@tanstack/preact-query'\n *\n * function App({ children }: { children: ComponentChildren }) {\n *   const { reset } = useQueryErrorResetBoundary()\n *   const [error, resetError] = useErrorBoundary(() => reset())\n *\n *   if (error) {\n *     return (\n *       <div>\n *         There was an error!\n *         <button onClick={() => resetError()}>Try again</button>\n *       </div>\n *     )\n *   }\n *\n *   return children\n * }\n * ```\n */\nexport const useQueryErrorResetBoundary = () =>\n  useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\n/**\n * A render-prop function usable as `children` on `QueryErrorResetBoundary`.\n *\n * @param value - The boundary's {@link QueryErrorResetBoundaryValue}.\n * @returns The children to render.\n */\nexport type QueryErrorResetBoundaryFunction = (\n  value: QueryErrorResetBoundaryValue,\n) => ComponentChildren\n\n/**\n * The props accepted by `QueryErrorResetBoundary`.\n */\nexport interface QueryErrorResetBoundaryProps {\n  /**\n   * Either a plain node, or a function that receives the boundary's {@link QueryErrorResetBoundaryValue} and\n   * returns a node.\n   */\n  children: QueryErrorResetBoundaryFunction | ComponentChildren\n}\n\n/**\n * When using `suspense` or `throwOnError` in your queries, you need a way to let queries know that you want to\n * try again when re-rendering after some error occurred. With the `QueryErrorResetBoundary` component you can\n * reset any query errors within the boundaries of the component.\n *\n * @returns The `children`, rendered as-is, or called with the boundary's {@link QueryErrorResetBoundaryValue}\n * if `children` is a function.\n *\n * @example\n * ```tsx\n * import { useErrorBoundary } from 'preact/hooks'\n * import type { ComponentChildren } from 'preact'\n * import { QueryErrorResetBoundary } from '@tanstack/preact-query'\n *\n * function ErrorBoundary({\n *   children,\n *   reset,\n * }: {\n *   children: ComponentChildren\n *   reset: () => void\n * }) {\n *   const [error, resetError] = useErrorBoundary(() => reset())\n *\n *   if (error) {\n *     return (\n *       <div>\n *         There was an error!\n *         <button onClick={() => resetError()}>Try again</button>\n *       </div>\n *     )\n *   }\n *\n *   return children\n * }\n *\n * const App = () => (\n *   <QueryErrorResetBoundary>\n *     {({ reset }) => (\n *       <ErrorBoundary reset={reset}>\n *         <Page />\n *       </ErrorBoundary>\n *     )}\n *   </QueryErrorResetBoundary>\n * )\n * ```\n */\nexport const QueryErrorResetBoundary = ({\n  children,\n}: QueryErrorResetBoundaryProps) => {\n  const [value] = useState(() => createValue())\n  return (\n    <QueryErrorResetBoundaryContext.Provider value={value}>\n      {typeof children === 'function' ? children(value) : children}\n    </QueryErrorResetBoundaryContext.Provider>\n  )\n}\n"],"mappings":";;;;;AAoCA,SAAS,cAA4C;CACnD,IAAI,UAAU;CACd,OAAO;EACL,kBAAkB;GAChB,UAAU;EACZ;EACA,aAAa;GACX,UAAU;EACZ;EACA,eAAe;GACb,OAAO;EACT;CACF;AACF;AAEA,MAAM,kCAAA,GAAiCA,OAAAA,cAAAA,CAAc,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiClE,MAAa,oCAAA,GACXC,aAAAA,WAAAA,CAAW,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuE3C,MAAa,2BAA2B,EACtC,eACkC;CAClC,MAAM,CAAC,UAAA,GAASC,aAAAA,SAAAA,OAAe,YAAY,CAAC;CAC5C,OACE,iBAAA,GAAA,mBAAA,IAAA,CAAC,+BAA+B,UAAhC;EAAgD;EAC7C,UAAA,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;CACb,CAAA;AAE7C"}