@raf-query/core 0.10.2 → 0.10.3

package/CHANGELOG.md

@@ -1,11 +1,17 @@
 # Changelog
 
+## [0.10.3](https://github.com/KATT/raf-query/compare/0.10.2...0.10.3) (2026-10-16)
+
+### Features
+
+* **core:** add QueryBinding, a framework-free useQuery for bindings ([#197](https://github.com/KATT/raf-query/issues/197)) ([4865802](https://github.com/KATT/raf-query/commit/48658024f4d21d43ce8274de379a19c8898b6173)), references [#194](https://github.com/KATT/raf-query/issues/194)
+
 ## [0.10.2](https://github.com/KATT/raf-query/compare/0.10.1...0.10.2) (2026-10-16)
 
 ### Features
 
-* **react:** re-render useQuery readers of the thenable's status when the first load settles (2/3) ([#198](https://github.com/KATT/raf-query/issues/198)) ([436d83c](https://github.com/KATT/raf-query/commit/436d83cfd6a3944265eb56d5597c322342c5a6c6))
-* **react:** type useQuery's promise as a Thenable (1/3) ([#200](https://github.com/KATT/raf-query/issues/200)) ([47e5309](https://github.com/KATT/raf-query/commit/47e530957565a2bd345642ae7a4be5d3c501ffb2))
+- **react:** re-render useQuery readers of the thenable's status when the first load settles (2/3) ([#198](https://github.com/KATT/raf-query/issues/198)) ([436d83c](https://github.com/KATT/raf-query/commit/436d83cfd6a3944265eb56d5597c322342c5a6c6))
+- **react:** type useQuery's promise as a Thenable (1/3) ([#200](https://github.com/KATT/raf-query/issues/200)) ([47e5309](https://github.com/KATT/raf-query/commit/47e530957565a2bd345642ae7a4be5d3c501ffb2))
 
 ## [0.10.1](https://github.com/KATT/raf-query/compare/0.10.0...0.10.1) (2026-10-16)
 

package/dist/binding.d.mts

@@ -0,0 +1,92 @@
+import { QueryFactory, QueryHandle } from "./options.mjs";
+import { Query, query_d_exports } from "./query.mjs";
+import { QueryClient } from "./client.mjs";
+import { Options, QueryObserver, observer_d_exports } from "./observer.mjs";
+import { ReadValue, UseQueryControls, UseQueryOptions, UseQueryThrowOptions } from "./controls.mjs";
+declare namespace binding_d_exports {
+  export { Hooks, QueryBinding, ReadOptions, Result, ResultWithData, Source, makeUnsafe, observerOptions, queryFor, subscribeUnsafe, syncUnsafe };
+}
+/** A read's options: the observer's, and `throwOnError` for typed errors. */
+export type ReadOptions<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = UseQueryOptions & UseQueryThrowOptions<TFactory> & {
+  readonly throwOnError?: TThrow;
+};
+/**
+ * What a binding's `useQuery` returns: the query's controls, the `promise`
+ * of the data to show, and that `data` once it's there. Each property is a
+ * getter that calls {@link Hooks.track}, so destructuring reads it once.
+ */
+export type Result<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = UseQueryControls<TFactory> & {
+  /** The promise's data once it has settled, else `undefined`. */
+  readonly data: ReadValue<TFactory, TThrow> | undefined;
+  /**
+   * Settles with the data to show. A new promise per data version, already
+   * settled once the cache has data.
+   */
+  readonly promise: Promise<ReadValue<TFactory, TThrow>>;
+};
+/** {@link Result} for a handle from `ensure` or `fetch`. */
+export type ResultWithData<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = Result<TFactory, TThrow> & {
+  /** The query's data. The handle's `data` until the cache has data again. */
+  readonly data: ReadValue<TFactory, TThrow>;
+};
+/** How a framework plugs into a binding. */
+export interface Hooks {
+  /**
+   * Runs when the result changed: a property something read, or a pending
+   * promise something read settling in place. Typically bumps the version.
+   */
+  readonly notify: () => void;
+  /**
+   * Runs on every read of the result, before the read, so the framework
+   * re-runs whatever read it after {@link Hooks.notify}. Typically reads a
+   * version signal.
+   */
+  readonly track: () => void;
+  /**
+   * Runs cache writes (starting a read can notify observers synchronously)
+   * outside the framework's tracking. Default: runs `f` as is.
+   */
+  readonly untracked?: <A>(f: () => A) => A;
+}
+/** Where a binding reads its handle and options from. */
+export interface Source<TFactory extends QueryFactory> {
+  readonly handle: () => QueryHandle<TFactory>;
+  readonly options: () => UseQueryOptions & {
+    readonly throwOnError?: boolean;
+  };
+}
+/** One component's read of a query. */
+export interface QueryBinding<TFactory extends QueryFactory = QueryFactory> {
+  readonly client: QueryClient<unknown>;
+  readonly observer: QueryObserver<TFactory>;
+  /** The result, the same object for the binding's life. */
+  readonly result: Result<TFactory, boolean>;
+}
+/**
+ * The query a handle points at. Calls the factory, so callers keep it for
+ * as long as the handle is the same.
+ */
+export declare function queryFor<TFactory extends QueryFactory>(client: QueryClient<unknown>, factory: TFactory, handle: QueryHandle<TFactory>): Query<TFactory>;
+/** The observer's part of a read's options. */
+export declare function observerOptions(options: UseQueryOptions): Options;
+/**
+ * Bind `factory` to the handle and options `source` returns. Reads the
+ * query and observes it, but doesn't subscribe: call {@link subscribeUnsafe}
+ * where the framework mounts, in the browser.
+ */
+export declare function makeUnsafe<TFactory extends QueryFactory>(client: QueryClient<unknown>, factory: TFactory, source: Source<TFactory>, hooks: Hooks): QueryBinding<TFactory>;
+/**
+ * Follow the source: switch to a new handle's query, or new options. Reads
+ * call it themselves, so markup that reads before the framework's effects
+ * run still sees the new query. Bindings also call it from an effect, so a
+ * new handle is observed even when nothing reads the result.
+ */
+export declare function syncUnsafe<TFactory extends QueryFactory>(self: QueryBinding<TFactory>): void;
+/**
+ * Notify {@link Hooks.notify} on result changes from now on. A server
+ * render reads once and never unmounts, so bindings call it in the browser
+ * only. Returns the unsubscribe.
+ */
+export declare function subscribeUnsafe<TFactory extends QueryFactory>(self: QueryBinding<TFactory>): () => void;
+//#endregion
+export { binding_d_exports };

package/dist/binding.mjs

@@ -0,0 +1,186 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { hashKey } from "./key.mjs";
+import { readUnsafe } from "./query.mjs";
+import { promiseControls, resultThenable } from "./controls.mjs";
+import { getOptimisticResultUnsafe, getUnsafe, makeUnsafe as makeUnsafe$1, setOptionsUnsafe, subscribeUnsafe as subscribeUnsafe$1, trackProp } from "./observer.mjs";
+import { Result } from "effect";
+//#region src/binding.ts
+/**
+* What a framework's `useQuery` does, without the framework: one observer
+* per component, following the handle and options it reads through
+* getters, and a result of getters over the observer. A binding supplies
+* {@link Hooks}: how a read is tracked, how a change is announced, and how
+* cache writes run outside the framework's tracking. The Vue and Svelte
+* packages are this plus their reactivity and lifecycle.
+*
+* Synchronous throughout, for renders.
+*/
+var binding_exports = /* @__PURE__ */ __exportAll({
+	makeUnsafe: () => makeUnsafe,
+	observerOptions: () => observerOptions,
+	queryFor: () => queryFor,
+	subscribeUnsafe: () => subscribeUnsafe,
+	syncUnsafe: () => syncUnsafe
+});
+/**
+* The query a handle points at. Calls the factory, so callers keep it for
+* as long as the handle is the same.
+*/
+function queryFor(client, factory, handle) {
+	const args = [handle.input];
+	return client.getQuery(factory, ...args);
+}
+/** The observer's part of a read's options. */
+function observerOptions(options) {
+	return {
+		refetchInterval: options.refetchInterval,
+		refetchOnReconnect: options.refetchOnReconnect,
+		refetchOnWindowFocus: options.refetchOnWindowFocus,
+		whilePending: options.whilePending
+	};
+}
+function sameObserverOptions(a, b) {
+	return a.refetchInterval === b.refetchInterval && a.refetchOnReconnect === b.refetchOnReconnect && a.refetchOnWindowFocus === b.refetchOnWindowFocus && a.whilePending === b.whilePending;
+}
+function stateOf(self) {
+	return self;
+}
+const runNow = (f) => f();
+/**
+* Bind `factory` to the handle and options `source` returns. Reads the
+* query and observes it, but doesn't subscribe: call {@link subscribeUnsafe}
+* where the framework mounts, in the browser.
+*/
+function makeUnsafe(client, factory, source, hooks) {
+	return (hooks.untracked ?? runNow)(() => {
+		const handle = source.handle();
+		const query = queryFor(client, factory, handle);
+		const options = observerOptions(source.options());
+		readUnsafe(query);
+		const state = {
+			awaited: /* @__PURE__ */ new WeakSet(),
+			client,
+			factory,
+			handle,
+			hooks,
+			observer: makeUnsafe$1(query, options),
+			options,
+			query,
+			source
+		};
+		return Object.assign(state, { result: resultOf(state) });
+	});
+}
+/**
+* Follow the source: switch to a new handle's query, or new options. Reads
+* call it themselves, so markup that reads before the framework's effects
+* run still sees the new query. Bindings also call it from an effect, so a
+* new handle is observed even when nothing reads the result.
+*/
+function syncUnsafe(self) {
+	sync(stateOf(self));
+}
+function sync(impl) {
+	const handle = impl.source.handle();
+	const options = observerOptions(impl.source.options());
+	const newQuery = handle !== impl.handle && hashKey(handle.key) !== impl.query.hash;
+	impl.handle = handle;
+	if (!newQuery && sameObserverOptions(options, impl.options)) return;
+	(impl.hooks.untracked ?? runNow)(() => {
+		if (newQuery) {
+			impl.query = queryFor(impl.client, impl.factory, handle);
+			readUnsafe(impl.query);
+		}
+		impl.options = options;
+		setOptionsUnsafe(impl.observer, impl.query, options);
+	});
+}
+/**
+* Notify {@link Hooks.notify} on result changes from now on. A server
+* render reads once and never unmounts, so bindings call it in the browser
+* only. Returns the unsubscribe.
+*/
+function subscribeUnsafe(self) {
+	const impl = stateOf(self);
+	return subscribeUnsafe$1(impl.observer, impl.hooks.notify);
+}
+function resultOf(impl) {
+	const { hooks, observer } = impl;
+	function read(name) {
+		sync(impl);
+		hooks.track();
+		trackProp(observer, name);
+		return impl.client.isServer ? getOptimisticResultUnsafe(observer, impl.query, impl.options) : getUnsafe(observer);
+	}
+	function throwOnError() {
+		return impl.source.options().throwOnError ?? impl.client.throwOnError;
+	}
+	function shown() {
+		const promise = read("promise").promise;
+		if (promise.status === "pending" && !impl.awaited.has(promise)) {
+			impl.awaited.add(promise);
+			promise.then(hooks.notify, hooks.notify);
+		}
+		return throwOnError() ? promise : resultThenable(promise);
+	}
+	function controls() {
+		return promiseControls(getUnsafe(observer));
+	}
+	return {
+		get data() {
+			const promise = shown();
+			if (promise.status === "fulfilled") return promise.value;
+			const handle = impl.handle;
+			if (!("data" in handle)) return;
+			const data = handle.data;
+			return throwOnError() ? data : Result.succeed(data);
+		},
+		get error() {
+			return read("error").error;
+		},
+		fetchNextPage: () => controls().fetchNextPage(),
+		fetchPreviousPage: () => controls().fetchPreviousPage(),
+		get hash() {
+			return read("hash").hash;
+		},
+		get hasNextPage() {
+			return read("hasNextPage").hasNextPage;
+		},
+		get hasPreviousPage() {
+			return read("hasPreviousPage").hasPreviousPage;
+		},
+		get input() {
+			return read("input").input;
+		},
+		get isFetching() {
+			return read("isFetching").isFetching;
+		},
+		get isFetchingNextPage() {
+			return read("isFetchingNextPage").isFetchingNextPage;
+		},
+		get isFetchingPreviousPage() {
+			return read("isFetchingPreviousPage").isFetchingPreviousPage;
+		},
+		get isPending() {
+			return read("isPending").isPending;
+		},
+		get isPrevious() {
+			return read("isPrevious").isPrevious;
+		},
+		get isStale() {
+			return read("isStale").isStale;
+		},
+		get key() {
+			return read("key").key;
+		},
+		get promise() {
+			return shown();
+		},
+		refetch: () => controls().refetch(),
+		get updatedAt() {
+			return read("updatedAt").updatedAt;
+		}
+	};
+}
+//#endregion
+export { binding_exports, makeUnsafe, observerOptions, queryFor, subscribeUnsafe, syncUnsafe };

package/dist/index.d.mts

@@ -9,4 +9,5 @@ import { cache_d_exports } from "./cache.mjs";
 import { QueryClient, QueryClientConfig, dehydrate, hydrate } from "./client.mjs";
 import { observer_d_exports } from "./observer.mjs";
 import { HasTypedError, PagingControls, PromiseControls, QueryControls, ReadValue, ThrowsOnError, UseQueryControls, UseQueryOptions, UseQueryThrowOptions, promiseControls, resultThenable } from "./controls.mjs";
-export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedResult, type DehydratedState, type DehydratedStream, type ErrorOf, type HasTypedError, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InfiniteQueryTypes, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, type PagedQueryFactory, type PagingControls, type Pending, platform_d_exports as Platform, type PromiseControls, query_d_exports as Query, type QueryBehavior, cache_d_exports as QueryCache, QueryClient, type QueryClientConfig, type QueryControls, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryHandleWithData, type QueryKey, type QueryMeta, observer_d_exports as QueryObserver, type QueryOptions, type QueryTypes, type ReadValue, RedactedError, type Register, type RetryPolicy, type ServicesOf, type Settled, type Thenable, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryThrowOptions, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };
+import { binding_d_exports } from "./binding.mjs";
+export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedResult, type DehydratedState, type DehydratedStream, type ErrorOf, type HasTypedError, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InfiniteQueryTypes, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, type PagedQueryFactory, type PagingControls, type Pending, platform_d_exports as Platform, type PromiseControls, query_d_exports as Query, type QueryBehavior, binding_d_exports as QueryBinding, cache_d_exports as QueryCache, QueryClient, type QueryClientConfig, type QueryControls, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryHandleWithData, type QueryKey, type QueryMeta, observer_d_exports as QueryObserver, type QueryOptions, type QueryTypes, type ReadValue, RedactedError, type Register, type RetryPolicy, type ServicesOf, type Settled, type Thenable, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryThrowOptions, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };

package/dist/index.mjs

@@ -9,4 +9,5 @@ import { cache_exports } from "./cache.mjs";
 import { QueryClient, dehydrate, hydrate } from "./client.mjs";
 import { promiseControls, resultThenable } from "./controls.mjs";
 import { observer_exports } from "./observer.mjs";
-export { platform_exports as Platform, query_exports as Query, cache_exports as QueryCache, QueryClient, observer_exports as QueryObserver, RedactedError, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };
+import { binding_exports } from "./binding.mjs";
+export { platform_exports as Platform, query_exports as Query, binding_exports as QueryBinding, cache_exports as QueryCache, QueryClient, observer_exports as QueryObserver, RedactedError, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/core",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Framework-agnostic core of raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",