@raf-query/react 0.5.3 → 0.6.0

package/CHANGELOG.md

@@ -1,8 +1,26 @@
 # Changelog
 
+## [0.6.0](https://github.com/KATT/raf-query/compare/0.5.3...0.6.0) (2026-10-14)
+
+### ⚠ BREAKING CHANGES
+
+* **core:** LoadOptions takes no type argument, and QueryCache.LoadArgs is gone.
+
+* **testing:** render in an async act so suspended trees resume ([#78](https://github.com/KATT/raf-query/issues/78)) ([c706b9d](https://github.com/KATT/raf-query/commit/c706b9db0d3ba3ea2d5b3fd1e21dc8e1fe315b82))
+
+### Features
+
+* **core:** ssr: false runs a query in the browser only ([#77](https://github.com/KATT/raf-query/issues/77)) ([22c47bd](https://github.com/KATT/raf-query/commit/22c47bdad9da2e9e84728017db3dde636c5d4113))
+
+### Bug Fixes
+
+* **core:** infer generic factory makers passed inline to a verb ([#76](https://github.com/KATT/raf-query/issues/76)) ([f0616f7](https://github.com/KATT/raf-query/commit/f0616f7cd4288fb4a00e784f6d94dc3880d19a39))
+* **core:** keep data written while a page loads ([#75](https://github.com/KATT/raf-query/issues/75)) ([d1b8ae5](https://github.com/KATT/raf-query/commit/d1b8ae560540cea345dad1008f8b4d8a467f48aa))
+* **react:** let beforeLoad return handles in TanStack Start route context ([#74](https://github.com/KATT/raf-query/issues/74)) ([70c2121](https://github.com/KATT/raf-query/commit/70c2121a1926b4045049e6d9bfe56778262be42f))
+
 ## [0.5.3](https://github.com/KATT/raf-query/compare/0.5.2...0.5.3) (2026-10-14)
 
-* compare prefetch, ensure and fetch in the starting queries demo ([#73](https://github.com/KATT/raf-query/issues/73)) ([b26a65e](https://github.com/KATT/raf-query/commit/b26a65e3e003f18308ce456646eba1d3f50c1357))
+- compare prefetch, ensure and fetch in the starting queries demo ([#73](https://github.com/KATT/raf-query/issues/73)) ([b26a65e](https://github.com/KATT/raf-query/commit/b26a65e3e003f18308ce456646eba1d3f50c1357))
 
 ## [0.5.2](https://github.com/KATT/raf-query/compare/0.5.1...0.5.2) (2026-10-14)
 

package/dist/client.d.mts

@@ -1,4 +1,4 @@
-import { DataOf, DehydrateOptions, DehydratedState, EnsuredQueryHandle, HydrateOptions, InputArgs, InputOf, Query, QueryCache, QueryFactory, QueryHandle } from "@raf-query/core";
+import { DataOf, DehydrateOptions, DehydratedState, EnsuredQueryHandle, HydrateOptions, InputArgs, InputOf, LoadOptions, PagedQueryFactory, Query, QueryCache, QueryFactory, QueryHandle } from "@raf-query/core";
 import { Layer } from "effect";
 //#region src/client.d.ts
 export interface QueryClientConfig<TServices = never> extends QueryCache.Config {
@@ -40,13 +40,17 @@ export declare class QueryClient<TServices = never> {
    * browser. The handle is marked `ensured`, so `useQuery` returns its data
    * directly.
    */
-  ensure<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: QueryCache.LoadArgs<TFactory>): Promise<EnsuredQueryHandle<TFactory>>;
+  ensure<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): Promise<EnsuredQueryHandle<TFactory>>;
+  /** {@link ensure}, loading `options.pages` pages of a paged query. */
+  ensure<TFactory extends PagedQueryFactory<TServices>>(factory: TFactory, input: InputOf<TFactory>, options: LoadOptions): Promise<EnsuredQueryHandle<TFactory>>;
   /**
    * Start a query and resolve to its data. Waits on a cache miss and on
    * stale data (on the server, only invalidated data), so the data is fresh.
    * Rejects if that request fails.
    */
-  fetch<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: QueryCache.LoadArgs<TFactory>): Promise<DataOf<TFactory>>;
+  fetch<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): Promise<DataOf<TFactory>>;
+  /** {@link fetch}, loading `options.pages` pages of a paged query. */
+  fetch<TFactory extends PagedQueryFactory<TServices>>(factory: TFactory, input: InputOf<TFactory>, options: LoadOptions): Promise<DataOf<TFactory>>;
   /**
    * Mark queries stale and refetch the ones being read. Resolves once those
    * refetches settle, so an action stays pending until fresh data is on

package/dist/client.mjs

@@ -20,6 +20,10 @@ function runLoad(effect) {
 		throw Predicate.isTagged(error, "CancelledError") ? new DOMException("The query was cancelled", "AbortError") : error;
 	});
 }
+/** `ensure` / `fetch` arguments, forwarded to the cache's same verb. */
+function loadArgs(input, options) {
+	return unsafeCast([input, options]);
+}
 /**
 * The query cache, with Promise methods. Create one per request on the
 * server and one per browser tab. `effect` is the same cache's Effect API.
@@ -60,22 +64,11 @@ var QueryClient = class {
 	prefetch(factory, ...args) {
 		return Effect.runSync(provided(this.effect.prefetch(factory, ...args)));
 	}
-	/**
-	* Start a query and wait for it on a cache miss. Rejects if that request
-	* fails. Stale cached data resolves immediately and revalidates in the
-	* browser. The handle is marked `ensured`, so `useQuery` returns its data
-	* directly.
-	*/
-	ensure(factory, ...args) {
-		return runLoad(provided(this.effect.ensure(factory, ...args)));
+	ensure(factory, input, options) {
+		return runLoad(provided(this.effect.ensure(factory, ...loadArgs(input, options))));
 	}
-	/**
-	* Start a query and resolve to its data. Waits on a cache miss and on
-	* stale data (on the server, only invalidated data), so the data is fresh.
-	* Rejects if that request fails.
-	*/
-	fetch(factory, ...args) {
-		return runLoad(provided(this.effect.fetch(factory, ...args)));
+	fetch(factory, input, options) {
+		return runLoad(provided(this.effect.fetch(factory, ...loadArgs(input, options))));
 	}
 	/**
 	* Mark queries stale and refetch the ones being read. Resolves once those

package/dist/tanstack-router-shared.d.mts

@@ -1,7 +1,18 @@
 import { QueryClient } from "./client.mjs";
-import { DehydrateOptions, DehydratedState, HydrateOptions } from "@raf-query/core";
+import { DehydrateOptions, DehydratedState, EnsuredQueryHandle, HydrateOptions, QueryHandle } from "@raf-query/core";
 import { AnyRouter } from "@tanstack/react-router";
 //#region src/tanstack-router-shared.d.ts
+declare module "@tanstack/react-router" {
+  interface SerializableExtensions {
+    /**
+     * Handles are `{ key, input, ensured? }`, which the router's serializer
+     * sends as is. Its type check can't see that on its own: keys are
+     * `ReadonlyArray<unknown>`, and the handle type names its factory.
+     * So `beforeLoad` can put handles in route context.
+     */
+    rafQueryHandle: EnsuredQueryHandle | QueryHandle;
+  }
+}
 export interface RouterIntegrationOptions<TRouter extends AnyRouter> {
   readonly dehydrateOptions?: DehydrateOptions;
   /** Navigate when a `queryFn` throws `redirect()`. Default `true`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/react",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "React bindings for raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",
@@ -47,7 +47,7 @@
     }
   },
   "dependencies": {
-    "@raf-query/core": "0.5.3"
+    "@raf-query/core": "0.6.0"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.170.0",