@raf-query/core 0.11.1 → 0.12.0

package/dist/root.d.mts

@@ -0,0 +1,82 @@
+//#region src/root.d.ts
+/**
+ * Root types, the way tRPC v12 types a client from its links: each link and
+ * feature declares the `meta` fields it reads, a client's `meta` is what its
+ * parts declare, and builders bound to a root (`bindQueryOptions`) carry it
+ * as a phantom on the options they build.
+ */
+/** A query's `meta` when its builder isn't bound to a root. */
+export type QueryMeta = Readonly<Record<string, unknown>>;
+/** What a link or feature declares: the `meta` fields it reads. */
+export interface Decl {
+  readonly meta?: object;
+}
+/** A root's types. */
+export interface RootTypes {
+  readonly meta: object;
+}
+/** The root of the unbound builders. A type only, never a value. */
+export interface DefaultTypes {
+  readonly "~default": true;
+  readonly meta: QueryMeta;
+}
+/**
+ * The root of a client typed only as `QueryClient`: any root. The one way
+ * an invariant phantom takes every root.
+ */
+export type AnyRoot = any;
+/** Whether `TTypes` is {@link AnyRoot}. */
+export type IsAnyRoot<TTypes> = 0 extends 1 & TTypes ? true : false;
+/**
+ * Phantom carrier of a part's declaration, `undefined` at runtime.
+ * Invariant, so a part that declares nothing doesn't absorb the
+ * declarations of the others in an array.
+ */
+export interface Declares<TDecl extends Decl> {
+  readonly "~decl"?: {
+    readonly in: (decl: TDecl) => void;
+    readonly out: TDecl;
+  };
+}
+/** Any link or feature, whatever it declares. */
+export interface AnyPart {
+  readonly "~decl"?: {
+    readonly in: (decl: never) => void;
+    readonly out: unknown;
+  };
+}
+/**
+ * The `meta` a declaration adds to its root. Every declared key is present
+ * and may be `undefined`: roots of all-optional metas would be assignable to
+ * one another. Queries pass a `Partial` of it.
+ */
+export type MetaOfDecl<TDecl> = TDecl extends {
+  readonly meta?: infer TMeta extends object;
+} ? Present<TMeta> : unknown;
+/**
+ * Every key of `T` required, its value possibly `undefined`. Mapping over
+ * `Exclude<keyof T, never>` rather than `keyof T` drops the modifiers
+ * without dropping `undefined`, which `-?` would.
+ */
+type Present<T> = { readonly [K in Exclude<keyof T, never>]: T[K] | undefined; };
+type DeclOf<TPart> = TPart extends {
+  readonly "~decl"?: {
+    readonly out: infer TDecl;
+  };
+} ? TDecl : never;
+type Intersect<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends ((value: infer TIntersection) => void) ? TIntersection : never;
+type Flat<T> = { readonly [K in keyof T]: T[K]; };
+/** A root's `meta`: what its links and features declare. */
+export type MetaOf<TParts extends ReadonlyArray<AnyPart>> = [DeclOf<TParts[number]>] extends [never] ? Flat<unknown> : Flat<Intersect<MetaOfDecl<DeclOf<TParts[number]>>>>;
+declare const rootBrand: unique symbol;
+/** Phantom carrier of the root a factory's builder is bound to. Never set at runtime. */
+export interface RootTag<TTypes extends RootTypes> {
+  readonly [rootBrand]: TTypes;
+}
+/** A root's types, from a client or from a function that makes one. */
+export type RootOf<T> = T extends ((...args: never) => infer TClient) ? RootOf<TClient> : T extends {
+  readonly "~types"?: {
+    readonly root: (types: infer TTypes extends RootTypes) => unknown;
+  };
+} ? TTypes : never;
+//#endregion

package/dist/structural-sharing/structural-sharing.mjs

@@ -0,0 +1,32 @@
+//#region src/structural-sharing/structural-sharing.ts
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/**
+* `next`, reusing every part of `previous` that is deeply equal to it, so
+* unchanged objects keep their identity and memoized readers skip work.
+*/
+function replaceEqualDeep(previous, next) {
+	if (Object.is(previous, next)) return previous;
+	const arrays = isPlainArray(previous) && isPlainArray(next);
+	if (!arrays && !(isPlainObject(previous) && isPlainObject(next))) return next;
+	const before = previous;
+	const after = next;
+	const names = Object.keys(after);
+	let same = names.length === Object.keys(before).length;
+	const values = names.map((name) => {
+		const own = Object.hasOwn(before, name);
+		const value = replaceEqualDeep(own ? before[name] : void 0, after[name]);
+		if (!own || value !== before[name]) same = false;
+		return value;
+	});
+	if (same) return previous;
+	return arrays ? values : Object.fromEntries(names.map((name, index) => [name, values[index]]));
+}
+//#endregion
+export { replaceEqualDeep };

package/dist/subscribe.d.mts

@@ -0,0 +1,15 @@
+//#region src/subscribe.d.ts
+/**
+ * The kernel's one subscription primitive: `subscribe(listener, { signal })`.
+ * Unsubscribe by aborting the signal, or by calling what it returns. There
+ * is no error channel: errors live in entry state.
+ */
+export interface SubscribeOptions {
+  readonly signal?: AbortSignal;
+}
+export interface Listeners<TEvent> {
+  emit(event: TEvent): void;
+  readonly size: number;
+  subscribe(listener: (event: TEvent) => void, options?: SubscribeOptions): () => void;
+}
+//#endregion

package/dist/subscribe.mjs

@@ -0,0 +1,29 @@
+//#region src/subscribe.ts
+function listeners(onSizeChange) {
+	const set = /* @__PURE__ */ new Set();
+	return {
+		emit(event) {
+			for (const item of set) item.listener(event);
+		},
+		get size() {
+			return set.size;
+		},
+		subscribe(listener, options) {
+			const signal = options?.signal;
+			if (signal?.aborted) return () => {};
+			const item = { listener };
+			set.add(item);
+			onSizeChange?.(set.size);
+			const unsubscribe = () => {
+				if (set.delete(item)) {
+					signal?.removeEventListener("abort", unsubscribe);
+					onSizeChange?.(set.size);
+				}
+			};
+			signal?.addEventListener("abort", unsubscribe, { once: true });
+			return unsubscribe;
+		}
+	};
+}
+//#endregion
+export { listeners };

package/dist/thenable.d.mts

@@ -1,31 +1,27 @@
 //#region src/thenable.d.ts
 /**
- * Promises that carry their own result, in the fields React's `use()` reads
- * before suspending (`status`, `value`, `reason`). A settled one can be read
+ * Promises that carry their own result in the fields React's `use()` reads
+ * before suspending (`status`, `value`, `reason`). A settled one is read
  * synchronously, so React renders it without a fallback.
  */
-interface PendingStatus {
-  readonly status: "pending";
-}
-interface FulfilledStatus<T> {
-  readonly status: "fulfilled";
-  readonly value: T;
-}
-interface RejectedStatus {
+export type Thenable<T> = Promise<T> & ({
   readonly reason: unknown;
   readonly status: "rejected";
-}
-/**
- * A promise that says whether it has settled, and with what. `status` moves
- * from `"pending"` to `"fulfilled"` (with `value`) or `"rejected"` (with
- * `reason`) once, when the promise settles.
- */
-export type Thenable<T> = Promise<T> & (FulfilledStatus<T> | PendingStatus | RejectedStatus);
+} | {
+  readonly status: "fulfilled";
+  readonly value: T;
+} | {
+  readonly status: "pending";
+});
 export declare function fulfilled<T>(value: T): Thenable<T>;
+export declare function rejected<T>(reason: unknown): Thenable<T>;
 export interface Pending<T> {
   readonly promise: Thenable<T>;
   reject(reason: unknown): void;
   resolve(value: T): void;
 }
+/** A pending thenable that settles in place, so `use()` resumes on it. */
 export declare function pending<T>(): Pending<T>;
+/** `thenable` with `map` applied to its value, cached per source thenable. */
+export declare function mapThenable<T, U>(cache: WeakMap<Thenable<unknown>, Thenable<unknown>>, thenable: Thenable<T>, map: (value: T) => U): Thenable<U>;
 //#endregion

package/dist/thenable.mjs

@@ -1,9 +1,4 @@
 //#region src/thenable.ts
-/**
-* Promises that carry their own result, in the fields React's `use()` reads
-* before suspending (`status`, `value`, `reason`). A settled one can be read
-* synchronously, so React renders it without a fallback.
-*/
 const noop = () => {};
 function fulfilled(value) {
 	return Object.assign(Promise.resolve(value), {
@@ -11,6 +6,15 @@ function fulfilled(value) {
 		value
 	});
 }
+function rejected(reason) {
+	const promise = Promise.reject(reason);
+	promise.catch(noop);
+	return Object.assign(promise, {
+		reason,
+		status: "rejected"
+	});
+}
+/** A pending thenable that settles in place, so `use()` resumes on it. */
 function pending() {
 	const deferred = Promise.withResolvers();
 	const promise = Object.assign(deferred.promise, { status: "pending" });
@@ -33,5 +37,20 @@ function pending() {
 		}
 	};
 }
+/** `thenable` with `map` applied to its value, cached per source thenable. */
+function mapThenable(cache, thenable, map) {
+	const cached = cache.get(thenable);
+	if (cached) return cached;
+	let mapped;
+	if (thenable.status === "fulfilled") mapped = fulfilled(map(thenable.value));
+	else if (thenable.status === "rejected") mapped = rejected(thenable.reason);
+	else {
+		const next = pending();
+		thenable.then((value) => next.resolve(map(value)), (error) => next.reject(error));
+		mapped = next.promise;
+	}
+	cache.set(thenable, mapped);
+	return mapped;
+}
 //#endregion
-export { fulfilled, pending };
+export { fulfilled, mapThenable, pending, rejected };

package/dist/verbs.d.mts

@@ -0,0 +1,109 @@
+import { Group } from "./keys/keys.mjs";
+import { IsAnyRoot, RootTypes } from "./root.mjs";
+import { AnyInvalidation, AnyTarget, ParamArgs, Target } from "./keys/targets.mjs";
+import { InputArgs, InputOf, QueryFactory, RootOfFactory } from "./options.mjs";
+import { QueryClient } from "./client.mjs";
+import { InfiniteData } from "./infinite/infinite.mjs";
+//#region src/verbs.d.ts
+type DeepPartial<T> = T extends object ? { readonly [TName in keyof T]?: DeepPartial<T[TName]>; } : T;
+/**
+ * What `invalidateMany(factory, partial)` takes: part of the factory's
+ * input, whatever its key looks like.
+ */
+export type PartialInput<TFactory extends QueryFactory> = DeepPartial<InputOf<TFactory>>;
+/**
+ * The clients a factory's verbs take: its root's, or any client for a
+ * factory from an unbound builder.
+ */
+export type ClientFor<TFactory extends QueryFactory> = QueryClient<RootOfFactory<TFactory>>;
+/**
+ * A target a client's root can match: its `where` reads that root's `meta`.
+ * A client typed only as `QueryClient` (from `useQueryClient()`, say) may
+ * be of any root, so it takes any target.
+ */
+export type TargetFor<TTypes extends RootTypes, TParam> = IsAnyRoot<TTypes> extends true ? Target<never, TParam> : Target<NoInfer<TTypes["meta"]>, TParam>;
+type ParamOf<TTarget> = TTarget extends {
+  readonly where: (query: never, param: infer TParam) => boolean;
+} ? TParam : never;
+/** A factory, if the client's root is its root; else nothing fits. */
+type FactoryFor<TTypes extends RootTypes, TFactory extends QueryFactory> = [QueryClient<TTypes>] extends [ClientFor<TFactory>] ? TFactory : never;
+/** A target on its own, if it needs no parameter; else with its parameter. */
+type BareTarget<TTypes extends RootTypes, TParam> = [] extends ParamArgs<TParam> ? TargetFor<TTypes, TParam> : readonly [TargetFor<TTypes, TParam>, TParam];
+type AnyItem = AnyTarget | Group | QueryFactory | readonly [AnyTarget | QueryFactory, unknown];
+/**
+ * What one element of a target list must be, given what was passed: a
+ * group, a factory of the client's root, a factory with a partial input, a
+ * target, or a target with its parameter.
+ */
+type Item<TTypes extends RootTypes, TItem> = TItem extends Group ? Group : TItem extends QueryFactory ? FactoryFor<TTypes, TItem> : TItem extends AnyTarget ? BareTarget<TTypes, ParamOf<TItem>> : TItem extends readonly [infer TFirst, unknown] ? TFirst extends QueryFactory ? readonly [FactoryFor<TTypes, TFirst>, PartialInput<TFirst>] : TFirst extends AnyTarget ? readonly [TargetFor<TTypes, ParamOf<TFirst>>, ParamOf<TFirst>] : AnyItem : AnyItem;
+/**
+ * Several targets for one verb call, each checked on its own: a group, a
+ * factory, `[factory, partial]`, a target, or `[target, param]`.
+ */
+export type TargetList<TTypes extends RootTypes, TItems extends ReadonlyArray<unknown>> = { readonly [TIndex in keyof TItems]: Item<TTypes, TItems[TIndex]>; };
+/** The data `setData` writes: plain for a query, paged for an infinite one. */
+type WritableData<TFactory extends QueryFactory> = ReturnType<TFactory> extends {
+  readonly select?: (data: infer TData) => unknown;
+} ? TData : InfiniteData<unknown>;
+/**
+ * Mark one query stale: a factory and its full input. If it's read, it
+ * refetches; resolves when that settles.
+ */
+export declare function invalidateOne<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, ...input: InputArgs<TFactory>): Promise<void>;
+/**
+ * Mark queries stale: a factory's (optionally only those whose input
+ * matches `partial`), a group's (keys that start with its path, whether
+ * the group built them or not), or those a target's `where` picks. Read
+ * queries refetch now; the rest when next read. Resolves when the
+ * refetches settle.
+ *
+ * Pass a list to invalidate several targets in one call: each query they
+ * cover refetches once, and the refetches run side by side. Awaiting one
+ * call after another runs them one after another instead.
+ *
+ * ```ts
+ * await invalidateMany(client, [todos, [issuesQuery, { status: "open" }], [ownedBy, "billing"]]);
+ * ```
+ */
+export declare function invalidateMany<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, partial?: PartialInput<TFactory>): Promise<void>;
+export declare function invalidateMany(client: QueryClient, group: Group): Promise<void>;
+export declare function invalidateMany<TTypes extends RootTypes, TParam = never>(client: QueryClient<TTypes>, target: TargetFor<TTypes, TParam>, ...param: ParamArgs<NoInfer<TParam>>): Promise<void>;
+export declare function invalidateMany<TTypes extends RootTypes, const TItems extends ReadonlyArray<unknown>>(client: QueryClient<TTypes>, targets: TargetList<TTypes, TItems>): Promise<void>;
+/** Mark every query stale; read ones refetch. For sign-out, or after any write. */
+export declare function invalidateAll(client: QueryClient): Promise<void>;
+/**
+ * Drop one query's data and error. If it's read, it suspends and refetches;
+ * resolves when that settles.
+ */
+export declare function resetOne<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, ...input: InputArgs<TFactory>): Promise<void>;
+/** {@link resetOne} for every query a target, or a list of them, covers. */
+export declare function resetMany<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, partial?: PartialInput<TFactory>): Promise<void>;
+export declare function resetMany(client: QueryClient, group: Group): Promise<void>;
+export declare function resetMany<TTypes extends RootTypes, TParam = never>(client: QueryClient<TTypes>, target: TargetFor<TTypes, TParam>, ...param: ParamArgs<NoInfer<TParam>>): Promise<void>;
+export declare function resetMany<TTypes extends RootTypes, const TItems extends ReadonlyArray<unknown>>(client: QueryClient<TTypes>, targets: TargetList<TTypes, TItems>): Promise<void>;
+/** {@link resetOne} for every query. */
+export declare function resetAll(client: QueryClient): Promise<void>;
+/** Remove one query from the cache, aborting its request. */
+export declare function removeOne<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, ...input: InputArgs<TFactory>): void;
+/** {@link removeOne} for every query a target, or a list of them, covers. */
+export declare function removeMany<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, partial?: PartialInput<TFactory>): void;
+export declare function removeMany(client: QueryClient, group: Group): void;
+export declare function removeMany<TTypes extends RootTypes, TParam = never>(client: QueryClient<TTypes>, target: TargetFor<TTypes, TParam>, ...param: ParamArgs<NoInfer<TParam>>): void;
+export declare function removeMany<TTypes extends RootTypes, const TItems extends ReadonlyArray<unknown>>(client: QueryClient<TTypes>, targets: TargetList<TTypes, TItems>): void;
+/** Remove every query, aborting their requests. */
+export declare function removeAll(client: QueryClient): void;
+/** New data for `setData`, or a function from the current data to it. */
+type Updater<TFactory extends QueryFactory> = ((previous: WritableData<TFactory> | undefined) => WritableData<TFactory>) | WritableData<TFactory>;
+/**
+ * Write a query's data, as if a request had just returned it. `updater`
+ * gets the current data, or `undefined` if there is none. A factory that
+ * takes no input (or an optional one) skips the input:
+ * `setData(client, todosQuery, updater)`.
+ */
+export declare function setData<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, ...updater: [] extends Parameters<TFactory> ? [updater: Updater<TFactory>] : never): void;
+export declare function setData<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, input: Parameters<TFactory> extends [] ? never : Parameters<TFactory>[0], updater: Updater<TFactory>): void;
+/** A query's cached data (before `select`), or `undefined`. */
+export declare function getData<TFactory extends QueryFactory>(client: ClientFor<TFactory>, factory: TFactory, ...input: InputArgs<TFactory>): WritableData<TFactory> | undefined;
+/** How many queries have a request in flight, optionally only a factory's, a group's or a target's. */
+export declare function isFetching(client: QueryClient, target?: AnyInvalidation): number;
+//#endregion

package/dist/verbs.mjs

@@ -0,0 +1,87 @@
+import { isArray, isFunction } from "./guards.mjs";
+import { hashKey } from "./keys/keys.mjs";
+import { entryStamp, matches, stampFor } from "./keys/targets.mjs";
+import { optionsOf } from "./options.mjs";
+import { entryOf, invalidate, remove, reset, write } from "./entry.mjs";
+//#region src/verbs.ts
+function hashOf(factory, input) {
+	return hashKey(optionsOf(factory, input).queryKey);
+}
+/** A stamp per target: one target and its argument, or each of a list. */
+function stampsOf(targets, arg, at) {
+	return (isArray(targets) ? targets : [[targets, arg]]).map((item) => isArray(item) ? stampFor(item[0], item[1], at) : stampFor(item, void 0, at));
+}
+function entriesMatching(client, stamps) {
+	return [...client["~entries"].values()].filter((entry) => stamps.some((stamp) => matches(entry, stamp)));
+}
+function settle(outcomes) {
+	return Promise.all(outcomes).then(() => {});
+}
+/**
+* Mark one query stale: a factory and its full input. If it's read, it
+* refetches; resolves when that settles.
+*/
+function invalidateOne(client, factory, ...input) {
+	return invalidate(client, (at) => [entryStamp(hashOf(factory, input[0]), at)]);
+}
+function invalidateMany(client, target, partial) {
+	return invalidate(client, (at) => stampsOf(target, partial, at));
+}
+/** Mark every query stale; read ones refetch. For sign-out, or after any write. */
+function invalidateAll(client) {
+	return invalidate(client, (at) => [{
+		at,
+		kind: "all"
+	}]);
+}
+function oneEntry(client, factory, input) {
+	return client["~entries"].get(hashOf(factory, input));
+}
+/**
+* Drop one query's data and error. If it's read, it suspends and refetches;
+* resolves when that settles.
+*/
+function resetOne(client, factory, ...input) {
+	const entry = oneEntry(client, factory, input[0]);
+	return settle(entry ? [reset(entry)] : []);
+}
+function resetMany(client, target, partial) {
+	return settle(entriesMatching(client, stampsOf(target, partial, 0)).map(reset));
+}
+/** {@link resetOne} for every query. */
+function resetAll(client) {
+	return settle([...client["~entries"].values()].map(reset));
+}
+/** Remove one query from the cache, aborting its request. */
+function removeOne(client, factory, ...input) {
+	const entry = oneEntry(client, factory, input[0]);
+	if (entry) remove(entry);
+}
+function removeMany(client, target, partial) {
+	for (const entry of entriesMatching(client, stampsOf(target, partial, 0))) remove(entry);
+}
+/** Remove every query, aborting their requests. */
+function removeAll(client) {
+	for (const entry of client["~entries"].values()) remove(entry);
+}
+function setData(client, factory, ...args) {
+	const [input, updater] = args.length < 2 ? [void 0, args[0]] : args;
+	const entry = entryOf(client, factory, input);
+	const previous = entry.state.hasData ? entry.state.data : void 0;
+	const data = isFunction(updater) ? updater(previous) : updater;
+	write(entry, data, client.clock.now(), ++client["~seq"]);
+}
+/** A query's cached data (before `select`), or `undefined`. */
+function getData(client, factory, ...input) {
+	const entry = oneEntry(client, factory, input[0]);
+	return entry?.state.hasData ? entry.state.data : void 0;
+}
+/** How many queries have a request in flight, optionally only a factory's, a group's or a target's. */
+function isFetching(client, target) {
+	return entriesMatching(client, [target === void 0 ? {
+		at: 0,
+		kind: "all"
+	} : stampFor(target, void 0, 0)]).filter((entry) => entry.state.isFetching).length;
+}
+//#endregion
+export { getData, invalidateAll, invalidateMany, invalidateOne, isFetching, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, setData };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/core",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Framework-agnostic core of raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",
@@ -31,18 +31,22 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index.mjs"
-  },
-  "peerDependencies": {
-    "effect": "^4.0.0"
+    ".": "./dist/index.mjs",
+    "./internal": "./dist/internal.mjs"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.1",
+    "@testing-library/react": "16.3.3",
     "@types/node": "26.6.4",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
     "@vitest/coverage-v8": "5.0.1",
-    "effect": "^4.0.1",
+    "fast-check": "4.10.2",
+    "happy-dom": "21.0.1",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
     "typescript": "7.0.2",
-    "vite-plus": "1.0.0"
+    "vite-plus": "1.0.0",
+    "vitest": "5.0.1"
   },
   "publishConfig": {
     "access": "public",
@@ -54,7 +58,7 @@
   "scripts": {
     "build": "vp pack",
     "test": "vp test",
-    "typecheck": "tsc",
+    "typecheck": "tsc && tsc -p tsconfig.no-node.json",
     "publish:npm": "pnpm pack --out package.tgz && npm publish package.tgz --access public && rm package.tgz"
   }
 }

package/dist/_virtual/_rolldown/runtime.mjs

@@ -1,13 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll };

package/dist/all-keyed.d.mts

@@ -1,18 +0,0 @@
-//#region src/all-keyed.d.ts
-/** The resolved form of a record passed to {@link allKeyed}. */
-export type Settled<TRecord> = { -readonly [TKey in keyof TRecord]: Awaited<TRecord[TKey]>; };
-/**
- * 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 }),
- * });
- * ```
- */
-export declare function allKeyed<TRecord extends {
-  readonly [key: string]: unknown;
-}>(record: TRecord): Promise<Settled<TRecord>>;
-//#endregion

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/binding.d.mts

@@ -1,92 +0,0 @@
-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 };