@raf-query/core 0.11.1 → 0.13.0

package/dist/query.mjs

@@ -1,147 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { CancelledError as CancelledError$1, DisabledError as DisabledError$1, TypeId as TypeId$1, changes as changes$1, entryOf, fetch as fetch$1, hasNextPageUnsafe as hasNextPageUnsafe$1, hasPreviousPageUnsafe as hasPreviousPageUnsafe$1, invalidate as invalidate$1, isQuery as isQuery$1, isStaleUnsafe as isStaleUnsafe$1, metaOf, provide, readUnsafe as readUnsafe$1, reset as reset$1, revalidate, subscribeUnsafe as subscribeUnsafe$1 } from "./entry.mjs";
-import { Effect } from "effect";
-import { dual } from "effect/Function";
-//#region src/query.ts
-/**
-* One cache entry, as a data type: a `Query` carries its key, handle and
-* options, and the functions here read it, subscribe to it and run its
-* requests. Get one from `QueryCache.getQuery(factory, input)`.
-*
-* Requests are Effects. The `*Unsafe` functions read and subscribe
-* synchronously, for renders and external stores that can't run an Effect.
-*/
-var query_exports = /* @__PURE__ */ __exportAll({
-	CancelledError: () => CancelledError,
-	DisabledError: () => DisabledError,
-	TypeId: () => TypeId,
-	changes: () => changes,
-	fetch: () => fetch,
-	fetchNextPage: () => fetchNextPage,
-	fetchPreviousPage: () => fetchPreviousPage,
-	get: () => get,
-	getUnsafe: () => getUnsafe,
-	hasNextPageUnsafe: () => hasNextPageUnsafe,
-	hasPreviousPageUnsafe: () => hasPreviousPageUnsafe,
-	invalidate: () => invalidate,
-	isQuery: () => isQuery,
-	isStaleUnsafe: () => isStaleUnsafe,
-	metaUnsafe: () => metaUnsafe,
-	observerCountUnsafe: () => observerCountUnsafe,
-	readUnsafe: () => readUnsafe,
-	refetch: () => refetch,
-	reset: () => reset,
-	returnsEffectUnsafe: () => returnsEffectUnsafe,
-	revalidateUnsafe: () => revalidateUnsafe,
-	subscribeUnsafe: () => subscribeUnsafe
-});
-const TypeId = TypeId$1;
-const CancelledError = CancelledError$1;
-const DisabledError = DisabledError$1;
-const isQuery = isQuery$1;
-function typed(effect) {
-	return effect;
-}
-function typedState(state) {
-	return state;
-}
-/**
-* Start a request, or join the one in flight. Fails with the request's
-* error, or a {@link CancelledError} if the entry leaves the cache first.
-* The entry's requests run with this fiber's services from now on, as after
-* a `QueryCache` verb.
-*/
-const fetch = dual((args) => isQuery(args[0]), (self, request) => typed(Effect.contextWith((caller) => {
-	const entry = entryOf(self);
-	provide(entry, caller);
-	return fetch$1(entry, request);
-})));
-/** Refetch now; succeeds when the request settles, whatever its outcome. */
-function refetch(self) {
-	return entryOf(self).commands.refetch;
-}
-/** Load the page after the last one; succeeds once it settles. */
-function fetchNextPage(self) {
-	return entryOf(self).commands.fetchNextPage;
-}
-/** Load the page before the first one; succeeds once it settles. */
-function fetchPreviousPage(self) {
-	return entryOf(self).commands.fetchPreviousPage;
-}
-/** Mark stale, and refetch if read; succeeds once that refetch settles. */
-function invalidate(self) {
-	return invalidate$1(entryOf(self));
-}
-/**
-* Drop data and errors, back to the state of a new entry. Readers suspend
-* and refetch; succeeds when that refetch settles.
-*/
-function reset(self) {
-	return reset$1(entryOf(self));
-}
-/**
-* The query's `meta`: the latest factory call's (the one it was hydrated
-* with, before any), else the cache default's.
-*/
-function metaUnsafe(self) {
-	return metaOf(entryOf(self));
-}
-/**
-* Whether the query's `queryFn` returns an Effect (`true`) or a promise or
-* plain value (`false`), as of its last call, on this cache or the one its
-* data was hydrated from. `undefined` until one has run. Bindings read typed
-* errors as a `Result` only for Effects.
-*/
-function returnsEffectUnsafe(self) {
-	return entryOf(self).returnsEffect;
-}
-/** The entry's current state. */
-function get(self) {
-	return Effect.sync(() => getUnsafe(self));
-}
-/** {@link get}, synchronously. */
-function getUnsafe(self) {
-	return typedState(entryOf(self).state);
-}
-/**
-* The entry's current state, then every change. Counts as a reader while
-* the stream runs, so invalidation and focus refetch it.
-*/
-function changes(self) {
-	return changes$1(entryOf(self));
-}
-/**
-* The promise a render should unwrap. Starts the first request if nothing
-* has, and retries a failed first load once its error has been shown.
-*/
-function readUnsafe(self) {
-	return readUnsafe$1(entryOf(self));
-}
-/**
-* Refetch cached data in the background if it's stale, as `prefetch` does
-* (on a server cache, only if invalidated). Does nothing without data or
-* while a request is in flight.
-*/
-function revalidateUnsafe(self) {
-	revalidate(entryOf(self));
-}
-/** Listen for state changes. Subscribed entries count as read. */
-function subscribeUnsafe(self, listener, options) {
-	return subscribeUnsafe$1(entryOf(self), listener, options);
-}
-/** Staleness as of now; `state.isStale` is only kept current while read. */
-function isStaleUnsafe(self) {
-	return isStaleUnsafe$1(entryOf(self));
-}
-function hasNextPageUnsafe(self) {
-	return hasNextPageUnsafe$1(entryOf(self));
-}
-function hasPreviousPageUnsafe(self) {
-	return hasPreviousPageUnsafe$1(entryOf(self));
-}
-/** Readers currently subscribed. */
-function observerCountUnsafe(self) {
-	return entryOf(self).listeners.size;
-}
-//#endregion
-export { CancelledError, DisabledError, TypeId, changes, fetch, fetchNextPage, fetchPreviousPage, get, getUnsafe, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isQuery, isStaleUnsafe, metaUnsafe, observerCountUnsafe, query_exports, readUnsafe, refetch, reset, returnsEffectUnsafe, revalidateUnsafe, subscribeUnsafe };

package/dist/request.mjs

@@ -1,47 +0,0 @@
-import { Context, Effect, Scope } from "effect";
-//#region src/request.ts
-function isEffectResult(result) {
-	return Effect.isEffect(result);
-}
-/**
-* One `queryFn` call as an Effect. The signal it gets aborts when the fiber
-* is interrupted; a returned Effect runs in the same fiber, so interrupting
-* the request interrupts it. Plain values settle like promises, a microtask
-* later. A `queryFn` that throws instead of returning is a defect, as in
-* `Effect.sync`.
-*/
-function fromQueryFn(call) {
-	return Effect.callback((resume, signal) => {
-		let result;
-		try {
-			result = call(signal);
-		} catch (error) {
-			resume(Effect.die(error));
-			return;
-		}
-		if (isEffectResult(result)) {
-			resume(result);
-			return;
-		}
-		Promise.resolve(result).then((value) => resume(Effect.succeed(value)), (error) => resume(Effect.fail(error)));
-	});
-}
-/**
-* The services a request runs with: the cache's, under those of the verb
-* that last called for the entry. The caller's `Scope` is left out: a
-* request outlives the call that started it.
-*/
-function requestServices(cache, caller) {
-	return Context.merge(cache, Context.omit(Scope.Scope)(caller));
-}
-/**
-* A request as it runs: in a `raf-query.request` span, with `services`,
-* which hold what its `queryFn` Effect needs (entries erase that type with
-* the data's). Typed failures become the query's error; defects are logged
-* too, since nothing else reports them.
-*/
-function runRequest(request, hash, services) {
-	return request.pipe(Effect.tapDefect((defect) => Effect.logError("raf-query: queryFn died", defect)), Effect.withSpan("raf-query.request", { attributes: { "raf_query.hash": hash } }), Effect.provideContext(services));
-}
-//#endregion
-export { fromQueryFn, requestServices, runRequest };

package/dist/retry.mjs

@@ -1,25 +0,0 @@
-import { Effect, Predicate, Schedule } from "effect";
-//#region src/retry.ts
-/** Doubling from 1 s, at most 30 s. */
-const defaultDelays = /*#__PURE__*/ Schedule.min([Schedule.exponential("1 second"), Schedule.spaced("30 seconds")]);
-function delays(retryDelay) {
-	if (retryDelay === void 0) return defaultDelays;
-	if (Predicate.isNumber(retryDelay)) return Schedule.spaced(retryDelay);
-	return Schedule.forever.pipe(Schedule.modifyDelay((step) => Effect.succeed(retryDelay(step.attempt, step.input))));
-}
-/**
-* A query's retry options as one `Schedule`, or `undefined` when it doesn't
-* retry. `retryDelay` sets the delays; a count or predicate in `retry` stops
-* the schedule, given the attempt number (1 after the first failure) and the
-* error.
-*/
-function retrySchedule(behavior, isServer) {
-	const retry = behavior.retry ?? (isServer ? 0 : 3);
-	if (Schedule.isSchedule(retry)) return retry;
-	if (retry === false || retry === 0) return;
-	const schedule = delays(behavior.retryDelay);
-	if (retry === true) return schedule;
-	return schedule.pipe(Schedule.while((step) => Predicate.isNumber(retry) ? step.attempt <= retry : retry(step.attempt, step.input)));
-}
-//#endregion
-export { retrySchedule };

package/dist/share.mjs

@@ -1,40 +0,0 @@
-import { isPlainRecord } from "./key.mjs";
-//#region src/share.ts
-function isPlainArray(value) {
-	return Array.isArray(value) && value.length === Object.keys(value).length;
-}
-function share(previous, next, depth) {
-	if (previous === next || depth > 500) return next;
-	if (isPlainArray(previous) && isPlainArray(next)) {
-		let equal = previous.length === next.length;
-		const copy = next.map((item, index) => {
-			const shared = share(previous[index], item, depth + 1);
-			equal &&= shared === previous[index];
-			return shared;
-		});
-		return equal ? previous : copy;
-	}
-	if (isPlainRecord(previous) && isPlainRecord(next)) {
-		const names = Object.keys(next);
-		let equal = names.length === Object.keys(previous).length;
-		const copy = {};
-		for (const name of names) {
-			const shared = share(previous[name], next[name], depth + 1);
-			equal &&= shared === previous[name] && Object.hasOwn(previous, name);
-			copy[name] = shared;
-		}
-		return equal ? previous : copy;
-	}
-	return next;
-}
-/**
-* `next`, reusing every part of `previous` that is deeply equal to it: all
-* of `previous` when nothing changed, else a copy of `next` whose unchanged
-* subtrees are `previous`'s. Only plain objects and arrays are compared;
-* anything else is taken from `next`. TanStack Query's `replaceEqualDeep`.
-*/
-function replaceEqualDeep(previous, next) {
-	return share(previous, next, 0);
-}
-//#endregion
-export { replaceEqualDeep };