@raf-query/react 0.11.1 → 0.13.0

package/dist/devtools-store.mjs

@@ -1,104 +0,0 @@
-import { Query } from "@raf-query/core";
-import { useSyncExternalStore } from "react";
-//#region src/devtools-store.ts
-const statuses = [
-	"fetching",
-	"error",
-	"stale",
-	"fresh",
-	"inactive"
-];
-const sortOrders = [
-	"status",
-	"hash",
-	"updated"
-];
-const stores = /* @__PURE__ */ new WeakMap();
-function statusOf(query) {
-	const state = Query.getUnsafe(query);
-	if (state.isFetching) return "fetching";
-	if (state.status === "error") return "error";
-	if (Query.observerCountUnsafe(query) === 0) return "inactive";
-	return Query.isStaleUnsafe(query) ? "stale" : "fresh";
-}
-function rowOf(query) {
-	return {
-		hash: query.hash,
-		observers: Query.observerCountUnsafe(query),
-		query,
-		state: Query.getUnsafe(query),
-		status: statusOf(query)
-	};
-}
-function createStore(client) {
-	const listeners = /* @__PURE__ */ new Set();
-	let version = 0;
-	let snapshotVersion = -1;
-	let snapshot = [];
-	let scheduled = false;
-	client.subscribe(() => {
-		version++;
-		if (scheduled || listeners.size === 0) return;
-		scheduled = true;
-		queueMicrotask(() => {
-			scheduled = false;
-			for (const listener of listeners) listener();
-		});
-	});
-	return {
-		getSnapshot: () => {
-			if (snapshotVersion !== version) {
-				snapshotVersion = version;
-				snapshot = client.getAll().map(rowOf);
-			}
-			return snapshot;
-		},
-		subscribe: (onChange) => {
-			listeners.add(onChange);
-			return () => {
-				listeners.delete(onChange);
-			};
-		}
-	};
-}
-function storeFor(client) {
-	let store = stores.get(client);
-	if (!store) {
-		store = createStore(client);
-		stores.set(client, store);
-	}
-	return store;
-}
-/** Every cache entry, re-rendering on each batch of cache events. */
-function useQueryRows(client) {
-	const store = storeFor(client);
-	return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-}
-function countByStatus(rows) {
-	const counts = {
-		error: 0,
-		fetching: 0,
-		fresh: 0,
-		inactive: 0,
-		stale: 0
-	};
-	for (const row of rows) counts[row.status]++;
-	return counts;
-}
-function compareRows(sortBy) {
-	return (a, b) => {
-		const primary = {
-			hash: 0,
-			status: statuses.indexOf(a.status) - statuses.indexOf(b.status),
-			updated: b.state.updatedAt - a.state.updatedAt
-		}[sortBy];
-		return primary === 0 ? a.hash.localeCompare(b.hash) : primary;
-	};
-}
-/** Rows whose hash contains `filter` (case-insensitive), sorted. */
-function visibleRows(rows, filter, sortBy) {
-	const needle = filter.trim().toLowerCase();
-	return rows.filter((row) => row.hash.toLowerCase().includes(needle)).toSorted(compareRows(sortBy));
-}
-//#endregion
-export { countByStatus, sortOrders, statuses, useQueryRows, visibleRows };

package/dist/hydration-boundary/sent.mjs

@@ -1,16 +0,0 @@
-//#region src/hydration-boundary/sent.ts
-const sentByClient = /* @__PURE__ */ new WeakMap();
-/**
-* Hashes of the request client's entries an earlier `HydrationBoundary`
-* already sent. Boundaries pass it as `sent`, so each entry crosses once.
-*/
-function sentHashes(client) {
-	let sent = sentByClient.get(client);
-	if (!sent) {
-		sent = /* @__PURE__ */ new Set();
-		sentByClient.set(client, sent);
-	}
-	return sent;
-}
-//#endregion
-export { sentHashes };

package/dist/query-provider/browser-requests.mjs

@@ -1,38 +0,0 @@
-import { Query } from "@raf-query/core";
-//#region src/query-provider/browser-requests.ts
-/**
-* The digest Next.js gives a boundary that renders only in the browser
-* (`next/dynamic` with `ssr: false`); it doesn't report those errors.
-*/
-const clientRendering = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
-const browserOnly = /* @__PURE__ */ new WeakSet();
-/**
-* Make a server client's render start no request: it reads what a
-* `HydrationBoundary` sent, and anything else loads in the browser.
-*/
-function requestInBrowserOnly(client) {
-	browserOnly.add(client);
-}
-/** Whether a render may start `client`'s requests (`useWaterfall`). */
-function startsRequests(client) {
-	return !(client.isServer && browserOnly.has(client));
-}
-/**
-* Thrown by a server render's read of a query no `HydrationBoundary` sent.
-* React renders the nearest Suspense fallback, and the browser renders the
-* content.
-*/
-var BrowserRenderError = class extends Error {
-	digest = clientRendering;
-	constructor(hash) {
-		super(`Query ${hash} loads in the browser: no HydrationBoundary sent it`);
-	}
-};
-/** Throw {@link BrowserRenderError} if reading `query` would start a request here. */
-function assertSent(client, query) {
-	if (startsRequests(client)) return;
-	const state = Query.getUnsafe(query);
-	if (!state.hasData && !state.isFetching && state.status !== "error") throw new BrowserRenderError(query.hash);
-}
-//#endregion
-export { assertSent, requestInBrowserOnly, startsRequests };

package/dist/query-provider/query-provider.d.mts

@@ -1,21 +0,0 @@
-import { QueryClientConfig } from "@raf-query/core";
-import { ReactNode } from "react";
-//#region src/query-provider/query-provider.d.ts
-/**
- * The query client provider for React Server Components apps. Creates one
- * client per server render and one per browser tab. The server render
- * starts no request: client components read what `HydrationBoundary` sent,
- * and a query nothing sent renders its Suspense fallback there and loads in
- * the browser.
- *
- * ```tsx
- * // app/layout.tsx
- * <QueryProvider>{props.children}</QueryProvider>
- * ```
- */
-export declare function QueryProvider(props: {
-  readonly children?: ReactNode;
-  /** Options for the client it creates. */
-  readonly config?: QueryClientConfig;
-}): import("react").JSX.Element;
-//#endregion

package/dist/query-provider/query-provider.mjs

@@ -1,33 +0,0 @@
-"use client";
-import { QueryClientProvider } from "../provider.mjs";
-import { requestInBrowserOnly } from "./browser-requests.mjs";
-import { QueryClient } from "@raf-query/core";
-import { useState } from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/query-provider/query-provider.tsx
-/**
-* The query client provider for React Server Components apps. Creates one
-* client per server render and one per browser tab. The server render
-* starts no request: client components read what `HydrationBoundary` sent,
-* and a query nothing sent renders its Suspense fallback there and loads in
-* the browser.
-*
-* ```tsx
-* // app/layout.tsx
-* <QueryProvider>{props.children}</QueryProvider>
-* ```
-*/
-function QueryProvider(props) {
-	const config = props.config;
-	const [client] = useState(() => {
-		const created = new QueryClient(config);
-		requestInBrowserOnly(created);
-		return created;
-	});
-	return /* @__PURE__ */ jsx(QueryClientProvider, {
-		client,
-		children: props.children
-	});
-}
-//#endregion
-export { QueryProvider };

package/dist/use-waterfall.d.mts

@@ -1,18 +0,0 @@
-import { InputArgs, QueryFactory, QueryHandle } from "@raf-query/core";
-//#region src/use-waterfall.d.ts
-/**
- * Start a query during render and return its handle, for inputs only known
- * at render time (an id from a parent query's data). Each call is a request
- * waterfall: prefer starting the query in a loader or server component.
- * Like `prefetch` in a loader, it refetches stale cached data in the
- * background, once per mount and input. Under `QueryProvider` it
- * starts nothing on the server: the reader's Suspense boundary renders its
- * fallback there, and the query loads in the browser.
- *
- * ```tsx
- * const author = useWaterfall(authorQuery, { id: post.authorId });
- * const [authorPromise] = useQuery(authorQuery, author);
- * ```
- */
-export declare function useWaterfall<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): QueryHandle<TFactory>;
-//#endregion

package/dist/use-waterfall.mjs

@@ -1,41 +0,0 @@
-"use client";
-import { useQueryClient } from "./provider.mjs";
-import { startsRequests } from "./query-provider/browser-requests.mjs";
-import { Query } from "@raf-query/core";
-import { useState } from "react";
-//#region src/use-waterfall.ts
-/**
-* First loads a waterfall suspended on. A suspended mount keeps no state, so
-* this is how its retry knows the data it finds is the load it just waited
-* for, not cached data to revalidate.
-*/
-const waitedFor = /* @__PURE__ */ new WeakSet();
-/**
-* Start a query during render and return its handle, for inputs only known
-* at render time (an id from a parent query's data). Each call is a request
-* waterfall: prefer starting the query in a loader or server component.
-* Like `prefetch` in a loader, it refetches stale cached data in the
-* background, once per mount and input. Under `QueryProvider` it
-* starts nothing on the server: the reader's Suspense boundary renders its
-* fallback there, and the query loads in the browser.
-*
-* ```tsx
-* const author = useWaterfall(authorQuery, { id: post.authorId });
-* const [authorPromise] = useQuery(authorQuery, author);
-* ```
-*/
-function useWaterfall(factory, ...args) {
-	const client = useQueryClient();
-	const query = client.getQuery(factory, ...args);
-	const [started, setStarted] = useState();
-	if (!startsRequests(client)) return query.handle;
-	const promise = Query.readUnsafe(query);
-	if (started !== query.hash) {
-		if (!Query.getUnsafe(query).hasData) waitedFor.add(promise);
-		else if (!waitedFor.delete(promise)) Query.revalidateUnsafe(query);
-		setStarted(query.hash);
-	} else if (Query.getUnsafe(query).hasData) waitedFor.delete(promise);
-	return query.handle;
-}
-//#endregion
-export { useWaterfall };