@raf-query/core 0.11.0 → 0.12.0

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 };