@raf-query/core 0.0.18 → 0.1.0

package/dist/all-keyed.mjs

@@ -1,19 +0,0 @@
-//#region src/all-keyed.ts
-/**
-* Ponyfill of the TC39 `Promise.allKeyed` proposal: a record of promises in,
-* a promise of the same record out, rejecting on the first failure.
-*
-* ```ts
-* const data = await allKeyed({
-*   post: qc.ensure(postQuery, { slug }),
-*   author: qc.ensure(authorQuery, { slug }),
-* });
-* ```
-*/
-async function allKeyed(record) {
-	const keys = Object.keys(record);
-	const values = await Promise.all(keys.map((key) => record[key]));
-	return Object.fromEntries(keys.map((key, index) => [key, values[index]]));
-}
-//#endregion
-export { allKeyed };

package/dist/client.d.mts

@@ -1,123 +0,0 @@
-import { QueryKey } from "./key.mjs";
-import { DataOf, EnsuredQueryHandle, InputArgs, InputOf, LoadOptions, QueryBehavior, QueryFactory, QueryHandle } from "./options.mjs";
-import { Query, QueryState } from "./query.mjs";
-import { Effect, Stream } from "effect";
-//#region src/client.d.ts
-export interface QueryClientConfig {
-  /** Defaults for every query; a factory's own options win. */
-  readonly defaults?: QueryBehavior;
-  /**
-   * Whether this client runs on the server. Detected from `window`. Server
-   * clients don't retry, never garbage-collect, skip stale timers, and reuse
-   * cached data in `prefetch` / `ensure` / `fetch` instead of revalidating
-   * it, unless `invalidate` marked it.
-   */
-  readonly isServer?: boolean;
-  /** Called with every failed request, including failed prefetches. */
-  onError?(error: unknown, query: Query): void;
-}
-/** Emitted by {@link QueryClient.subscribe} for every cache change. */
-export type CacheEvent = {
-  readonly query: Query;
-  /** `observers`: a reader subscribed or unsubscribed. */
-  readonly type: "added" | "observers" | "removed" | "updated";
-} | {
-  /** A request failed (after retries), with this error. */
-  readonly error: unknown;
-  readonly query: Query;
-  readonly type: "failed";
-};
-/** Matches cache entries by key prefix, or by exact key with `exact`. */
-export interface QueryFilter {
-  readonly exact?: boolean;
-  readonly queryKey: QueryKey;
-}
-/** `ensure` / `fetch` arguments: the input, then load options for paged factories. */
-export type LoadArgs<TFactory extends QueryFactory> = InputArgs<TFactory> | [input: InputOf<TFactory>, options: LoadOptions<TFactory>];
-/**
- * A new value, or a function of the current one. `previous` is `undefined`
- * both with no data and with `undefined` data.
- */
-export type Updater<TData> = TData | ((previous: TData | undefined) => TData);
-/** Effect-returning twins of the client's async methods. */
-export interface QueryClientEffect {
-  ensure<TFactory extends QueryFactory>(factory: TFactory, ...args: LoadArgs<TFactory>): Effect.Effect<EnsuredQueryHandle<TFactory>, unknown>;
-  fetch<TFactory extends QueryFactory>(factory: TFactory, ...args: LoadArgs<TFactory>): Effect.Effect<DataOf<TFactory>, unknown>;
-  invalidate<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Effect.Effect<void>;
-  invalidate(filter: QueryFilter): Effect.Effect<void>;
-  /**
-   * The entry's current state, then every change. Counts as a reader while
-   * the stream runs, so invalidation and focus refetch it.
-   */
-  watch<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Stream.Stream<QueryState<DataOf<TFactory>>>;
-}
-/**
- * The query cache. Create one per request on the server and one per browser
- * tab.
- */
-export declare class QueryClient {
-  #private;
-  /** Effect-returning versions of `ensure`, `fetch`, `invalidate`, plus `watch`. */
-  readonly effect: QueryClientEffect;
-  readonly isServer: boolean;
-  constructor(config?: QueryClientConfig);
-  /**
-   * The cache entry for a factory call, created if missing. Doesn't fetch.
-   * For bindings; apps use the verbs.
-   */
-  getQuery<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Query<DataOf<TFactory>, TFactory>;
-  /**
-   * Start a query without waiting and return its handle. Fresh data is
-   * reused; stale data refetches in the background (in the browser only, see
-   * {@link QueryClientConfig.isServer}). Errors surface where the data is
-   * read, never here.
-   */
-  prefetch<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): QueryHandle<TFactory>;
-  /**
-   * 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<TFactory extends QueryFactory>(factory: TFactory, ...args: LoadArgs<TFactory>): Promise<EnsuredQueryHandle<TFactory>>;
-  /** Like `ensure`, but resolves to the data. */
-  fetch<TFactory extends QueryFactory>(factory: TFactory, ...args: LoadArgs<TFactory>): 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
-   * screen.
-   */
-  invalidate<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Promise<void>;
-  invalidate(filter: QueryFilter): Promise<void>;
-  /**
-   * Drop queries' data and errors, as if they were never fetched. Read ones
-   * suspend and refetch; resolves once those refetches settle.
-   */
-  reset<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Promise<void>;
-  reset(filter: QueryFilter): Promise<void>;
-  /**
-   * Remove queries from the cache and abort their requests. Readers keep the
-   * removed entry until they render again.
-   */
-  remove<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): void;
-  remove(filter: QueryFilter): void;
-  /** Write data for a factory call. Readers re-render without suspending. */
-  setData<TFactory extends QueryFactory>(factory: TFactory, input: InputOf<TFactory>, updater: Updater<DataOf<TFactory>>): void;
-  /**
-   * Cached data for a factory call, or `undefined` if there is none. Data can
-   * itself be `undefined`; `getQuery(...).getState().hasData` tells them apart.
-   */
-  getData<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): DataOf<TFactory> | undefined;
-  /** Every entry, for devtools and integrations. */
-  getAll(): ReadonlyArray<Query>;
-  /** Listen to entries being added, updated, and removed. */
-  subscribe(listener: (event: CacheEvent) => void): () => void;
-  /** Drop every entry and abort in-flight requests. */
-  clear(): void;
-  /**
-   * Start refetching read, stale queries on window focus and reconnect.
-   * Returns the matching unmount. Providers call this; mounts are counted.
-   */
-  mount(): () => void;
-}
-//#endregion

package/dist/client.mjs

@@ -1,266 +0,0 @@
-import { unsafeCast } from "./cast.mjs";
-import { hashKey, matchesKey } from "./key.mjs";
-import { optionsFor } from "./options.mjs";
-import { QueryEntry } from "./query.mjs";
-import { Effect, Predicate, Queue, Stream } from "effect";
-//#region src/client.ts
-const caches = /* @__PURE__ */ new WeakMap();
-function cacheOf(client) {
-	const cache = caches.get(client);
-	if (!cache) throw new Error("Not a QueryClient");
-	return cache;
-}
-const noop = () => {};
-const identity = (value) => value;
-function isUpdateFunction(updater) {
-	return Predicate.isFunction(updater);
-}
-function typed(entry) {
-	return unsafeCast(entry);
-}
-function handleOf(entry) {
-	return entry.handle;
-}
-function ensuredHandleOf(entry) {
-	return {
-		...handleOf(entry),
-		ensured: true
-	};
-}
-/**
-* The query cache. Create one per request on the server and one per browser
-* tab.
-*/
-var QueryClient = class {
-	/** Effect-returning versions of `ensure`, `fetch`, `invalidate`, plus `watch`. */
-	effect;
-	isServer;
-	#cache = /* @__PURE__ */ new Map();
-	#host;
-	#listeners = /* @__PURE__ */ new Set();
-	#mounts = 0;
-	#unmountWindow = noop;
-	constructor(config = {}) {
-		this.isServer = config.isServer ?? !("window" in globalThis);
-		const emit = (event) => {
-			for (const listener of this.#listeners) listener(event);
-		};
-		this.#host = {
-			changed: (query) => emit({
-				query,
-				type: "updated"
-			}),
-			defaults: config.defaults ?? {},
-			isServer: this.isServer,
-			observersChanged: (query) => emit({
-				query,
-				type: "observers"
-			}),
-			remove: (query) => {
-				if (this.#cache.get(query.hash) === query) {
-					this.#cache.delete(query.hash);
-					query.destroy();
-					emit({
-						query,
-						type: "removed"
-					});
-				}
-			},
-			reportError: (error, query) => {
-				config.onError?.(error, query);
-				emit({
-					error,
-					query,
-					type: "failed"
-				});
-			}
-		};
-		caches.set(this, {
-			all: () => [...this.#cache.values()],
-			entryFor: (key) => this.#entryFor(key, hashKey(key))
-		});
-		this.effect = this.#effectApi();
-	}
-	/**
-	* The cache entry for a factory call, created if missing. Doesn't fetch.
-	* For bindings; apps use the verbs.
-	*/
-	getQuery(factory, ...args) {
-		return typed(this.#build(factory, args[0]));
-	}
-	/**
-	* Start a query without waiting and return its handle. Fresh data is
-	* reused; stale data refetches in the background (in the browser only, see
-	* {@link QueryClientConfig.isServer}). Errors surface where the data is
-	* read, never here.
-	*/
-	prefetch(factory, ...args) {
-		const entry = this.#build(factory, args[0]);
-		if (entry.getState().hasData) this.#revalidate(entry);
-		else entry.fetch().catch(noop);
-		return handleOf(entry);
-	}
-	/**
-	* 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.
-	*/
-	async ensure(factory, ...args) {
-		const entry = this.#build(factory, args[0]);
-		await this.#load(entry, args[1]?.pages);
-		return ensuredHandleOf(entry);
-	}
-	/** Like `ensure`, but resolves to the data. */
-	async fetch(factory, ...args) {
-		const entry = this.#build(factory, args[0]);
-		await this.#load(entry, args[1]?.pages);
-		const state = entry.getState();
-		if (!state.hasData) throw new Error(`Query ${entry.hash} has no data`);
-		return unsafeCast(state.data);
-	}
-	async invalidate(target, input) {
-		await Promise.all(this.#match(target, input).map((entry) => entry.invalidate()));
-	}
-	async reset(target, input) {
-		await Promise.all(this.#match(target, input).map((entry) => entry.reset()));
-	}
-	remove(target, input) {
-		for (const entry of this.#match(target, input)) this.#host.remove(entry);
-	}
-	/** Write data for a factory call. Readers re-render without suspending. */
-	setData(factory, input, updater) {
-		const entry = this.#build(factory, input);
-		const next = isUpdateFunction(updater) ? updater(typed(entry).getState().data) : updater;
-		entry.setData(next);
-	}
-	/**
-	* Cached data for a factory call, or `undefined` if there is none. Data can
-	* itself be `undefined`; `getQuery(...).getState().hasData` tells them apart.
-	*/
-	getData(factory, ...args) {
-		const options = optionsFor(factory, args[0]);
-		const entry = this.#cache.get(hashKey(options.queryKey));
-		return entry ? typed(entry).getState().data : void 0;
-	}
-	/** Every entry, for devtools and integrations. */
-	getAll() {
-		return [...this.#cache.values()];
-	}
-	/** Listen to entries being added, updated, and removed. */
-	subscribe(listener) {
-		this.#listeners.add(listener);
-		return () => {
-			this.#listeners.delete(listener);
-		};
-	}
-	/** Drop every entry and abort in-flight requests. */
-	clear() {
-		const entries = [...this.#cache.values()];
-		this.#cache.clear();
-		for (const entry of entries) {
-			entry.destroy();
-			for (const listener of this.#listeners) listener({
-				query: entry,
-				type: "removed"
-			});
-		}
-	}
-	/**
-	* Start refetching read, stale queries on window focus and reconnect.
-	* Returns the matching unmount. Providers call this; mounts are counted.
-	*/
-	mount() {
-		this.#mounts++;
-		if (this.#mounts === 1 && !this.isServer) this.#unmountWindow = this.#listenToWindow();
-		let mounted = true;
-		return () => {
-			if (!mounted) return;
-			mounted = false;
-			this.#mounts--;
-			if (this.#mounts === 0) {
-				this.#unmountWindow();
-				this.#unmountWindow = noop;
-			}
-		};
-	}
-	#entryFor(key, hash) {
-		const existing = this.#cache.get(hash);
-		if (existing) return existing;
-		const entry = new QueryEntry(this.#host, key, hash);
-		this.#cache.set(hash, entry);
-		for (const listener of this.#listeners) listener({
-			query: entry,
-			type: "added"
-		});
-		return entry;
-	}
-	#build(factory, input) {
-		const options = optionsFor(factory, input);
-		const entry = this.#entryFor(options.queryKey, hashKey(options.queryKey));
-		entry.setOptions(options, input);
-		return entry;
-	}
-	#load(entry, pages) {
-		const state = entry.getState();
-		if (!state.hasData) return entry.fetch({ pages });
-		this.#revalidate(entry);
-		return Promise.resolve(state.data);
-	}
-	/**
-	* Background refetch of cached data a verb reuses. A server client renders
-	* once, so a refetch there could only duplicate a request whose result is
-	* never shown; it refetches only what `invalidate` marked.
-	*/
-	#revalidate(entry) {
-		const state = entry.getState();
-		const wanted = this.isServer ? state.isInvalidated : entry.isStaleNow();
-		if (!state.isFetching && wanted) entry.fetch().catch(noop);
-	}
-	#match(target, input) {
-		if (Predicate.isFunction(target)) {
-			const entry = this.#cache.get(hashKey(optionsFor(target, input).queryKey));
-			return entry ? [entry] : [];
-		}
-		const hash = hashKey(target.queryKey);
-		return [...this.#cache.values()].filter((entry) => target.exact ? entry.hash === hash : matchesKey(entry.key, target.queryKey));
-	}
-	#listenToWindow() {
-		const each = (event) => {
-			for (const entry of this.#cache.values()) if (entry.isObserved) entry.onWindowEvent(event);
-		};
-		const onVisibilityChange = () => {
-			if (document.visibilityState === "visible") each("focus");
-		};
-		const onOnline = () => each("reconnect");
-		window.addEventListener("visibilitychange", onVisibilityChange);
-		window.addEventListener("online", onOnline);
-		return () => {
-			window.removeEventListener("visibilitychange", onVisibilityChange);
-			window.removeEventListener("online", onOnline);
-		};
-	}
-	#effectApi() {
-		const invalidate = (target, input) => Effect.promise(() => Promise.all(this.#match(target, input).map((entry) => entry.invalidate()))).pipe(Effect.asVoid);
-		return {
-			ensure: (factory, ...args) => Effect.tryPromise({
-				catch: identity,
-				try: () => this.ensure(factory, ...args)
-			}),
-			fetch: (factory, ...args) => Effect.tryPromise({
-				catch: identity,
-				try: () => this.fetch(factory, ...args)
-			}),
-			invalidate,
-			watch: (factory, ...args) => Stream.callback((queue) => {
-				const query = this.getQuery(factory, ...args);
-				return Effect.acquireRelease(Effect.sync(() => {
-					Queue.offerUnsafe(queue, query.getState());
-					return query.subscribe(() => Queue.offerUnsafe(queue, query.getState()));
-				}), (unsubscribe) => Effect.sync(unsubscribe));
-			})
-		};
-	}
-};
-//#endregion
-export { QueryClient, cacheOf };

package/dist/online.mjs

@@ -1,16 +0,0 @@
-import { Effect } from "effect";
-//#region src/online.ts
-function isOffline() {
-	return "window" in globalThis && "navigator" in globalThis && "onLine" in navigator && !navigator.onLine;
-}
-/**
-* Succeeds now if the browser is online, else on the window's next `online`
-* event. Interrupting it removes the listener.
-*/
-const whenOnline = Effect.suspend(() => isOffline() ? Effect.callback((resume) => {
-	const onOnline = () => resume(Effect.void);
-	window.addEventListener("online", onOnline, { once: true });
-	return Effect.sync(() => window.removeEventListener("online", onOnline));
-}) : Effect.void);
-//#endregion
-export { whenOnline };