@ahoo-wang/wow-react 9.2.0-rc.0

package/dist/hooks/useListQuery.d.ts

@@ -0,0 +1,68 @@
+import { FilterListQuery } from '@ahoo-wang/wow-client';
+import { ListQuery, ListQueryRequest } from '@ahoo-wang/wow-client/legacy';
+import { QueryHookOptions, QueryHookReturn } from '../types.js';
+/**
+ * Options of {@link useListQuery}: a list query and an `execute` that resolves
+ * to its rows.
+ *
+ * @template R - One row of the list
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default
+ * @template Q - The query type: `FilterListQuery` by default
+ */
+export interface UseListQueryOptions<R, FIELDS extends string = string, E = Error, Q extends ListQueryRequest<FIELDS> = FilterListQuery<FIELDS>> extends QueryHookOptions<Q, R[], E> {
+}
+/**
+ * What {@link useListQuery} returns: the rows as `result`.
+ *
+ * @template R - One row of the list
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default
+ * @template Q - The query type: `FilterListQuery` by default
+ */
+export interface UseListQueryReturn<R, FIELDS extends string = string, E = Error, Q extends ListQueryRequest<FIELDS> = FilterListQuery<FIELDS>> extends QueryHookReturn<Q, R[], E> {
+}
+/**
+ * Runs a list query through your own `execute` function and keeps the rows
+ * as state: typically a query client's `list` or `listState`.
+ *
+ * `execute` receives the query, the `attributes` option and an
+ * `AbortController`; hand the controller on so that a newer query, `abort()`
+ * or an unmount cancels the request. The query runs on mount and whenever
+ * `query` or `setQuery()` changes it; set `autoExecute: false` to run it only
+ * through `execute()`.
+ *
+ * Returns `result` (the rows, or `undefined` before the first success),
+ * `loading`, `error`, `status`, `execute`, `abort`, `reset`, `getQuery` and
+ * `setQuery`.
+ *
+ * @template R - One row of the list
+ * @template FIELDS - The field names the query may use. With a client whose
+ *   fields are narrower than `string`, as a generated client's are, pass
+ *   them here: TypeScript does not infer them from `execute` once `R` is given
+ * @template E - The error type, `Error` by default
+ *
+ * @example
+ * ```tsx
+ * import { desc, filter, listQuery, type SnapshotQueryClient } from '@ahoo-wang/wow-client';
+ * import { useListQuery } from '@ahoo-wang/wow-react';
+ *
+ * function LatestOrders({ client }: { client: SnapshotQueryClient<OrderState, OrderFields> }) {
+ *   const { result, loading, error } = useListQuery<OrderState, OrderFields>({
+ *     initialQuery: listQuery({
+ *       filter: filter.eq('state.status', 'PAID'),
+ *       sort: [desc('createTime')],
+ *       limit: 20,
+ *     }),
+ *     execute: (query, attributes, abortController) =>
+ *       client.listState(query, attributes, abortController),
+ *   });
+ *   if (error) return <p role="alert">{error.message}</p>;
+ *   if (loading || !result) return <p>Loading…</p>;
+ *   return <ul>{result.map(order => <li key={order.id}>{order.id}</li>)}</ul>;
+ * }
+ * ```
+ */
+export declare function useListQuery<R, FIELDS extends string = string, E = Error>(options: UseListQueryOptions<R, FIELDS, E, FilterListQuery<FIELDS>>): UseListQueryReturn<R, FIELDS, E, FilterListQuery<FIELDS>>;
+export declare function useListQuery<R, FIELDS extends string = string, E = Error>(options: UseListQueryOptions<R, FIELDS, E, ListQuery<FIELDS>>): UseListQueryReturn<R, FIELDS, E, ListQuery<FIELDS>>;
+export declare function useListQuery<R, FIELDS extends string = string, E = Error, Q extends ListQueryRequest<FIELDS> = FilterListQuery<FIELDS>>(options: UseListQueryOptions<R, FIELDS, E, Q>): UseListQueryReturn<R, FIELDS, E, Q>;

package/dist/hooks/useListStreamQuery.d.ts

@@ -0,0 +1,89 @@
+import { FilterListQuery } from '@ahoo-wang/wow-client';
+import { ListQuery, ListQueryRequest } from '@ahoo-wang/wow-client/legacy';
+import { ListStreamExecutor, QueryHookOptions, QueryHookReturn } from '../types.js';
+/**
+ * Options of {@link useListStreamQuery}: those of every query hook, with an
+ * `execute` that opens the stream.
+ *
+ * `onSuccess` receives every row once the stream has ended.
+ *
+ * @template R - One row of the stream: the `data` of each event
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default: a failed request
+ *   rejects with a `FetcherError`, an error event in the stream with a
+ *   `WowError`
+ * @template Q - The query type: `FilterListQuery` by default
+ */
+export interface UseListStreamQueryOptions<R, FIELDS extends string = string, E = Error, Q extends ListQueryRequest<FIELDS> = FilterListQuery<FIELDS>> extends Omit<QueryHookOptions<Q, R[], E>, 'execute'> {
+    /** Opens the stream for a query. */
+    execute: ListStreamExecutor<R, Q>;
+}
+/**
+ * What {@link useListStreamQuery} and `useFetcherListStreamQuery` return: the
+ * rows as they arrive, and whether the stream has ended.
+ *
+ * - `items` — the rows of the current query received so far, in order,
+ *   updated at most about once a frame (every 16 ms) while they arrive. A new
+ *   query starts from an empty list; `reset()` empties it; `abort()` and an
+ *   error keep the rows received before them.
+ * - `done` — the stream ended normally and `items` holds every row.
+ * - `loading` — from the request until the stream ends, fails or is aborted.
+ * - `error` — the request failed (`FetcherError`), or the server sent an error
+ *   event in the stream (`WowError`, with its `errorCode`).
+ * - `status` — `idle`, `loading`, `success` (the same as `done`) or `error`.
+ * - `execute()` runs the current query again and aborts the stream in flight;
+ *   `abort()` stops the stream; `reset()` stops it and empties `items`.
+ */
+export interface UseListStreamQueryReturn<R, FIELDS extends string = string, E = Error, Q extends ListQueryRequest<FIELDS> = FilterListQuery<FIELDS>> extends Omit<QueryHookReturn<Q, R[], E>, 'result'> {
+    /**
+     * The rows of the current query received so far, a new array at every
+     * update.
+     */
+    items: R[];
+    /** Whether the stream ended normally, so `items` holds every row. */
+    done: boolean;
+}
+/**
+ * Streams the rows of a list query as server-sent events and keeps them as
+ * state.
+ *
+ * The hook owns the stream: it reads it, collects the rows into `items`, and
+ * cancels it when a newer query starts, on `abort()` or `reset()`, and on
+ * unmount. Components render `items` and never hold a reader, so the hook is
+ * safe under StrictMode. `autoExecute` defaults to `true`.
+ *
+ * Pass a query client method as `execute` — it sends
+ * `Accept: text/event-stream` and turns error events into a `WowError` — or
+ * use `useFetcherListStreamQuery` with a URL.
+ *
+ * @template R - One row of the stream: the `data` of each event
+ * @template FIELDS - The field names the query may use. With a client whose
+ *   fields are narrower than `string`, as a generated client's are, pass
+ *   them here: TypeScript does not infer them from `execute` once `R` is given
+ * @template E - The error type
+ *
+ * @example
+ * ```tsx
+ * import { filter, listQuery, type SnapshotQueryClient } from '@ahoo-wang/wow-client';
+ * import { useListStreamQuery } from '@ahoo-wang/wow-react';
+ *
+ * function PaidOrders({ client }: { client: SnapshotQueryClient<OrderState, OrderFields> }) {
+ *   const { items, done, loading, error, abort } = useListStreamQuery<OrderState, OrderFields>({
+ *     initialQuery: listQuery({ filter: filter.eq('state.status', 'PAID') }),
+ *     execute: (query, attributes, abortController) =>
+ *       client.listStateStream(query, attributes, abortController),
+ *   });
+ *   if (error) return <p role="alert">{error.message}</p>;
+ *   return (
+ *     <>
+ *       <ul>{items.map(order => <li key={order.id}>{order.id}</li>)}</ul>
+ *       {loading && <button onClick={abort}>Stop</button>}
+ *       {done && <p>{items.length} orders</p>}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useListStreamQuery<R, FIELDS extends string = string, E = Error>(options: UseListStreamQueryOptions<R, FIELDS, E, FilterListQuery<FIELDS>>): UseListStreamQueryReturn<R, FIELDS, E, FilterListQuery<FIELDS>>;
+export declare function useListStreamQuery<R, FIELDS extends string = string, E = Error>(options: UseListStreamQueryOptions<R, FIELDS, E, ListQuery<FIELDS>>): UseListStreamQueryReturn<R, FIELDS, E, ListQuery<FIELDS>>;
+export declare function useListStreamQuery<R, FIELDS extends string = string, E = Error, Q extends ListQueryRequest<FIELDS> = FilterListQuery<FIELDS>>(options: UseListStreamQueryOptions<R, FIELDS, E, Q>): UseListStreamQueryReturn<R, FIELDS, E, Q>;

package/dist/hooks/usePagedQuery.d.ts

@@ -0,0 +1,68 @@
+import { FilterPagedQuery, PagedList } from '@ahoo-wang/wow-client';
+import { PagedQuery, PagedQueryRequest } from '@ahoo-wang/wow-client/legacy';
+import { QueryHookOptions, QueryHookReturn } from '../types.js';
+/**
+ * Options of {@link usePagedQuery}: a paged query and an `execute` that
+ * resolves to one page.
+ *
+ * @template R - One row of the page
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default
+ * @template Q - The query type: `FilterPagedQuery` by default
+ */
+export interface UsePagedQueryOptions<R, FIELDS extends string = string, E = Error, Q extends PagedQueryRequest<FIELDS> = FilterPagedQuery<FIELDS>> extends QueryHookOptions<Q, PagedList<R>, E> {
+}
+/**
+ * What {@link usePagedQuery} returns: the page (`total` and `list`) as
+ * `result`.
+ *
+ * @template R - One row of the page
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default
+ * @template Q - The query type: `FilterPagedQuery` by default
+ */
+export interface UsePagedQueryReturn<R, FIELDS extends string = string, E = Error, Q extends PagedQueryRequest<FIELDS> = FilterPagedQuery<FIELDS>> extends QueryHookReturn<Q, PagedList<R>, E> {
+}
+/**
+ * Runs a paged query through your own `execute` function and keeps the page
+ * as state: typically a query client's `paged` or `pagedState`.
+ *
+ * `execute` receives the query, the `attributes` option and an
+ * `AbortController`; hand the controller on so that a newer query, `abort()`
+ * or an unmount cancels the request. The query runs on mount and whenever
+ * `query` or `setQuery()` changes it — turn pages with `setQuery()`; set
+ * `autoExecute: false` to run it only through `execute()`.
+ *
+ * Returns `result` (`{ total, list }`, or `undefined` before the first
+ * success), `loading`, `error`, `status`, `execute`, `abort`, `reset`,
+ * `getQuery` and `setQuery`.
+ *
+ * @template R - One row of the page
+ * @template FIELDS - The field names the query may use. With a client whose
+ *   fields are narrower than `string`, as a generated client's are, pass
+ *   them here: TypeScript does not infer them from `execute` once `R` is given
+ * @template E - The error type, `Error` by default
+ *
+ * @example
+ * ```tsx
+ * import { filter, pagedQuery, type SnapshotQueryClient } from '@ahoo-wang/wow-client';
+ * import { usePagedQuery } from '@ahoo-wang/wow-react';
+ *
+ * function PaidOrders({ client, page }: { client: SnapshotQueryClient<OrderState, OrderFields>; page: number }) {
+ *   const { result, loading, error } = usePagedQuery<OrderState, OrderFields>({
+ *     query: pagedQuery({
+ *       filter: filter.eq('state.status', 'PAID'),
+ *       pagination: { index: page, size: 20 },
+ *     }),
+ *     execute: (query, attributes, abortController) =>
+ *       client.pagedState(query, attributes, abortController),
+ *   });
+ *   if (error) return <p role="alert">{error.message}</p>;
+ *   if (loading || !result) return <p>Loading…</p>;
+ *   return <p>{result.list.length} of {result.total}</p>;
+ * }
+ * ```
+ */
+export declare function usePagedQuery<R, FIELDS extends string = string, E = Error>(options: UsePagedQueryOptions<R, FIELDS, E, FilterPagedQuery<FIELDS>>): UsePagedQueryReturn<R, FIELDS, E, FilterPagedQuery<FIELDS>>;
+export declare function usePagedQuery<R, FIELDS extends string = string, E = Error>(options: UsePagedQueryOptions<R, FIELDS, E, PagedQuery<FIELDS>>): UsePagedQueryReturn<R, FIELDS, E, PagedQuery<FIELDS>>;
+export declare function usePagedQuery<R, FIELDS extends string = string, E = Error, Q extends PagedQueryRequest<FIELDS> = FilterPagedQuery<FIELDS>>(options: UsePagedQueryOptions<R, FIELDS, E, Q>): UsePagedQueryReturn<R, FIELDS, E, Q>;

package/dist/hooks/useSingleQuery.d.ts

@@ -0,0 +1,64 @@
+import { FilterSingleQuery } from '@ahoo-wang/wow-client';
+import { SingleQuery, SingleQueryRequest } from '@ahoo-wang/wow-client/legacy';
+import { QueryHookOptions, QueryHookReturn } from '../types.js';
+/**
+ * Options of {@link useSingleQuery}: a single query and an `execute` that
+ * resolves to one item.
+ *
+ * @template R - The item the query returns
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default
+ * @template Q - The query type: `FilterSingleQuery` by default
+ */
+export interface UseSingleQueryOptions<R, FIELDS extends string = string, E = Error, Q extends SingleQueryRequest<FIELDS> = FilterSingleQuery<FIELDS>> extends QueryHookOptions<Q, R, E> {
+}
+/**
+ * What {@link useSingleQuery} returns: the item as `result`.
+ *
+ * @template R - The item the query returns
+ * @template FIELDS - The field names the query may use
+ * @template E - The error type, `Error` by default
+ * @template Q - The query type: `FilterSingleQuery` by default
+ */
+export interface UseSingleQueryReturn<R, FIELDS extends string = string, E = Error, Q extends SingleQueryRequest<FIELDS> = FilterSingleQuery<FIELDS>> extends QueryHookReturn<Q, R, E> {
+}
+/**
+ * Runs a single query through your own `execute` function and keeps the
+ * result as state: typically a query client's `single` or `singleState`.
+ *
+ * `execute` receives the query, the `attributes` option and an
+ * `AbortController`; hand the controller on so that a newer query, `abort()`
+ * or an unmount cancels the request. The query runs on mount and whenever
+ * `query` or `setQuery()` changes it; set `autoExecute: false` to run it only
+ * through `execute()`.
+ *
+ * Returns `result` (the item, or `undefined` before the first success),
+ * `loading`, `error`, `status`, `execute`, `abort`, `reset`, `getQuery` and
+ * `setQuery`.
+ *
+ * @template R - The item the query returns
+ * @template FIELDS - The field names the query may use. With a client whose
+ *   fields are narrower than `string`, as a generated client's are, pass
+ *   them here: TypeScript does not infer them from `execute` once `R` is given
+ * @template E - The error type, `Error` by default
+ *
+ * @example
+ * ```tsx
+ * import { filter, singleQuery, type SnapshotQueryClient } from '@ahoo-wang/wow-client';
+ * import { useSingleQuery } from '@ahoo-wang/wow-react';
+ *
+ * function OrderStatus({ client, id }: { client: SnapshotQueryClient<OrderState, OrderFields>; id: string }) {
+ *   const { result, loading, error } = useSingleQuery<OrderState, OrderFields>({
+ *     query: singleQuery({ filter: filter.id(id) }),
+ *     execute: (query, attributes, abortController) =>
+ *       client.singleState(query, attributes, abortController),
+ *   });
+ *   if (error) return <p role="alert">{error.message}</p>;
+ *   if (loading || !result) return <p>Loading…</p>;
+ *   return <p>{result.status}</p>;
+ * }
+ * ```
+ */
+export declare function useSingleQuery<R, FIELDS extends string = string, E = Error>(options: UseSingleQueryOptions<R, FIELDS, E, FilterSingleQuery<FIELDS>>): UseSingleQueryReturn<R, FIELDS, E, FilterSingleQuery<FIELDS>>;
+export declare function useSingleQuery<R, FIELDS extends string = string, E = Error>(options: UseSingleQueryOptions<R, FIELDS, E, SingleQuery<FIELDS>>): UseSingleQueryReturn<R, FIELDS, E, SingleQuery<FIELDS>>;
+export declare function useSingleQuery<R, FIELDS extends string = string, E = Error, Q extends SingleQueryRequest<FIELDS> = FilterSingleQuery<FIELDS>>(options: UseSingleQueryOptions<R, FIELDS, E, Q>): UseSingleQueryReturn<R, FIELDS, E, Q>;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './hooks/useCountQuery.js';
+export * from './hooks/useFetcherCountQuery.js';
+export * from './hooks/useFetcherListQuery.js';
+export * from './hooks/useFetcherListStreamQuery.js';
+export * from './hooks/useFetcherPagedQuery.js';
+export * from './hooks/useFetcherSingleQuery.js';
+export * from './hooks/useListQuery.js';
+export * from './hooks/useListStreamQuery.js';
+export * from './hooks/usePagedQuery.js';
+export * from './hooks/useSingleQuery.js';
+export * from './types.js';

package/dist/index.es.js

@@ -0,0 +1,298 @@
+import { dequal as e } from "dequal";
+import { useCallback as t, useEffect as n, useLayoutEffect as r, useRef as i, useState as a } from "react";
+import { c as o } from "react/compiler-runtime";
+import { DEFAULT_FETCHER_NAME as s, JsonResultExtractor as c, getFetcher as l } from "@ahoo-wang/fetcher";
+import { QUERY_STREAM_ENDPOINT as u } from "@ahoo-wang/wow-client";
+//#endregion
+//#region src/internal/queryTransitions.ts
+function initialQueryState(e) {
+	return {
+		status: e ? "loading" : "idle",
+		result: void 0,
+		error: void 0
+	};
+}
+function queryTransition(e, t) {
+	switch (t.type) {
+		case "start": return {
+			status: "loading",
+			result: e.result,
+			error: void 0
+		};
+		case "succeed": return {
+			status: "success",
+			result: t.result,
+			error: void 0
+		};
+		case "fail": return {
+			status: "error",
+			result: e.result,
+			error: t.error
+		};
+		case "abort": return {
+			status: "idle",
+			result: e.result,
+			error: void 0
+		};
+		case "reset": return {
+			status: "idle",
+			result: void 0,
+			error: void 0
+		};
+	}
+}
+//#endregion
+//#region src/internal/useQueryRunner.ts
+function useContentStable(t) {
+	let [n, r] = a(t);
+	return n === t || e(n, t) ? n : (r(t), t);
+}
+async function notify(e, t, n) {
+	try {
+		await t?.(n);
+	} catch (t) {
+		console.warn(`wow-react: ${e} threw`, t);
+	}
+}
+function isAbortError(e) {
+	return e instanceof Error && e.name === "AbortError";
+}
+function useQueryRunner(e, o, s = !0) {
+	let c = e.autoExecute ?? !0, l = useContentStable(e.query), [u, d] = a(() => initialQueryState(c && (e.query ?? e.initialQuery) !== void 0)), f = i(e), p = i(e.query ?? e.initialQuery), m = i({ id: 0 }), h = i(!1);
+	r(() => {
+		f.current = e;
+	});
+	let g = t((e, t) => !h.current || m.current.id !== e ? !1 : (d((e) => queryTransition(e, t)), !0), []), _ = t(() => {
+		let { controller: e } = m.current;
+		m.current = { id: m.current.id + 1 }, e?.abort();
+	}, []), v = t(async () => {
+		let e = p.current;
+		if (!h.current || e === void 0) return;
+		m.current.controller?.abort();
+		let t = new AbortController(), n = m.current.id + 1;
+		m.current = {
+			id: n,
+			controller: t
+		}, d((e) => queryTransition(e, { type: "start" }));
+		let { execute: r, attributes: i } = f.current;
+		try {
+			let a = await r(e, i, t);
+			t.signal.aborted ? g(n, { type: "abort" }) : g(n, {
+				type: "succeed",
+				result: s ? a : void 0
+			}) && await notify("onSuccess", f.current.onSuccess, a);
+		} catch (e) {
+			t.signal.aborted || isAbortError(e) ? g(n, { type: "abort" }) : g(n, {
+				type: "fail",
+				error: e
+			}) && await notify("onError", f.current.onError, e);
+		} finally {
+			m.current.controller === t && (m.current = { id: m.current.id });
+		}
+	}, [g, s]), y = t(() => {
+		_(), d((e) => queryTransition(e, { type: "abort" }));
+	}, [_]), b = t(() => {
+		_(), d((e) => queryTransition(e, { type: "reset" }));
+	}, [_]), x = t(() => p.current, []), S = t((e) => {
+		p.current = e, (f.current.autoExecute ?? !0) && v();
+	}, [v]);
+	n(() => (h.current = !0, () => {
+		h.current = !1, _();
+	}), [_]);
+	let C = i(l);
+	return n(() => {
+		let e = l === void 0 && C.current !== void 0;
+		if (C.current = l, e) {
+			p.current = void 0, y();
+			return;
+		}
+		l !== void 0 && (p.current = l), c && v();
+	}, [
+		l,
+		o,
+		c,
+		v,
+		y
+	]), {
+		status: u.status,
+		loading: u.status === "loading",
+		result: u.result,
+		error: u.error,
+		execute: v,
+		abort: y,
+		reset: b,
+		getQuery: x,
+		setQuery: S
+	};
+}
+//#endregion
+//#region src/hooks/useCountQuery.ts
+function useCountQuery(e) {
+	return useQueryRunner(e);
+}
+//#endregion
+//#region src/internal/endpoint.ts
+function postQuery({ url: e, fetcher: t }) {
+	return (n, r, i) => l(t).post(e, {
+		body: n,
+		abortController: i
+	}, {
+		attributes: r,
+		resultExtractor: c
+	});
+}
+function postQueryStream({ url: e, fetcher: t }) {
+	return (n, r, i) => l(t).post(e, {
+		body: n,
+		headers: { ...u.headers },
+		abortController: i
+	}, {
+		attributes: r,
+		resultExtractor: u.resultExtractor
+	});
+}
+function endpointIdentity({ url: e, fetcher: t }) {
+	let n;
+	return n = t === void 0 ? `name:${s}` : typeof t == "string" ? `name:${t}` : "name" in t && typeof t.name == "string" ? `name:${t.name}` : `baseURL:${t.urlBuilder.baseURL}`, JSON.stringify([e, n]);
+}
+//#endregion
+//#region src/internal/useEndpointRunner.ts
+function useEndpointRunner(e) {
+	let t = o(13), n, r, i;
+	t[0] === e ? (n = t[1], r = t[2], i = t[3]) : ({url: i, fetcher: n, ...r} = e, t[0] = e, t[1] = n, t[2] = r, t[3] = i);
+	let a;
+	t[4] !== n || t[5] !== i ? (a = postQuery({
+		url: i,
+		fetcher: n
+	}), t[4] = n, t[5] = i, t[6] = a) : a = t[6];
+	let s;
+	t[7] !== r || t[8] !== a ? (s = {
+		...r,
+		execute: a
+	}, t[7] = r, t[8] = a, t[9] = s) : s = t[9];
+	let c;
+	return t[10] !== n || t[11] !== i ? (c = endpointIdentity({
+		url: i,
+		fetcher: n
+	}), t[10] = n, t[11] = i, t[12] = c) : c = t[12], useQueryRunner(s, c);
+}
+//#endregion
+//#region src/hooks/useFetcherCountQuery.ts
+function useFetcherCountQuery(e) {
+	return useEndpointRunner(e);
+}
+//#endregion
+//#region src/hooks/useFetcherListQuery.ts
+function useFetcherListQuery(e) {
+	return useEndpointRunner(e);
+}
+async function readStreamRows(e, t, n) {
+	let r = e.getReader(), i = [], a = 0, o = -Infinity, s, flush = () => {
+		s !== void 0 && clearTimeout(s), s = void 0, !(t.aborted || a === i.length) && (a = i.length, o = Date.now(), n(i.slice()));
+	}, schedule = () => {
+		if (s !== void 0) return;
+		let e = Math.max(0, o + 16 - Date.now());
+		s = setTimeout(flush, e);
+	}, cancel = () => {
+		r.cancel(t.reason).catch(() => {});
+	};
+	t.aborted ? cancel() : t.addEventListener("abort", cancel, { once: !0 });
+	try {
+		for (;;) {
+			let { done: e, value: t } = await r.read();
+			if (e) break;
+			i.push(t), schedule();
+		}
+		return flush(), i;
+	} catch (e) {
+		throw flush(), e;
+	} finally {
+		s !== void 0 && clearTimeout(s), t.removeEventListener("abort", cancel), r.releaseLock();
+	}
+}
+//#endregion
+//#region src/internal/useListStream.ts
+function useListStream(e, t) {
+	let n = o(18), [r, i] = a(_temp), s = e.execute, t0;
+	n[0] === s ? t0 = n[1] : (t0 = async (e, t, n) => (i([]), readStreamRows(await s(e, t, n), n.signal, i)), n[0] = s, n[1] = t0);
+	let c;
+	n[2] !== e || n[3] !== t0 ? (c = {
+		...e,
+		execute: t0
+	}, n[2] = e, n[3] = t0, n[4] = c) : c = n[4];
+	let { status: l, loading: u, error: d, execute: f, abort: p, reset: m, getQuery: h, setQuery: g } = useQueryRunner(c, t, !1), t2;
+	n[5] === m ? t2 = n[6] : (t2 = () => {
+		m(), i([]);
+	}, n[5] = m, n[6] = t2);
+	let _ = t2, v = l === "success", y;
+	return n[7] !== p || n[8] !== d || n[9] !== f || n[10] !== h || n[11] !== r || n[12] !== u || n[13] !== _ || n[14] !== g || n[15] !== l || n[16] !== v ? (y = {
+		items: r,
+		done: v,
+		loading: u,
+		error: d,
+		status: l,
+		execute: f,
+		abort: p,
+		reset: _,
+		getQuery: h,
+		setQuery: g
+	}, n[7] = p, n[8] = d, n[9] = f, n[10] = h, n[11] = r, n[12] = u, n[13] = _, n[14] = g, n[15] = l, n[16] = v, n[17] = y) : y = n[17], y;
+}
+function _temp() {
+	return [];
+}
+//#endregion
+//#region src/hooks/useFetcherListStreamQuery.ts
+function useFetcherListStreamQuery(e) {
+	let t = o(13), n, r, i;
+	t[0] === e ? (n = t[1], r = t[2], i = t[3]) : ({url: i, fetcher: n, ...r} = e, t[0] = e, t[1] = n, t[2] = r, t[3] = i);
+	let a;
+	t[4] !== n || t[5] !== i ? (a = postQueryStream({
+		url: i,
+		fetcher: n
+	}), t[4] = n, t[5] = i, t[6] = a) : a = t[6];
+	let s;
+	t[7] !== r || t[8] !== a ? (s = {
+		...r,
+		execute: a
+	}, t[7] = r, t[8] = a, t[9] = s) : s = t[9];
+	let c;
+	return t[10] !== n || t[11] !== i ? (c = endpointIdentity({
+		url: i,
+		fetcher: n
+	}), t[10] = n, t[11] = i, t[12] = c) : c = t[12], useListStream(s, c);
+}
+//#endregion
+//#region src/hooks/useFetcherPagedQuery.ts
+function useFetcherPagedQuery(e) {
+	return useEndpointRunner(e);
+}
+//#endregion
+//#region src/hooks/useFetcherSingleQuery.ts
+function useFetcherSingleQuery(e) {
+	return useEndpointRunner(e);
+}
+//#endregion
+//#region src/hooks/useListQuery.ts
+function useListQuery(e) {
+	return useQueryRunner(e);
+}
+//#endregion
+//#region src/hooks/useListStreamQuery.ts
+function useListStreamQuery(e) {
+	return useListStream(e);
+}
+//#endregion
+//#region src/hooks/usePagedQuery.ts
+function usePagedQuery(e) {
+	return useQueryRunner(e);
+}
+//#endregion
+//#region src/hooks/useSingleQuery.ts
+function useSingleQuery(e) {
+	return useQueryRunner(e);
+}
+//#endregion
+export { useCountQuery, useFetcherCountQuery, useFetcherListQuery, useFetcherListStreamQuery, useFetcherPagedQuery, useFetcherSingleQuery, useListQuery, useListStreamQuery, usePagedQuery, useSingleQuery };
+
+//# sourceMappingURL=index.es.js.map