@raf-query/core 0.0.18 → 0.1.0

package/dist/observer.mjs

@@ -1,4 +1,43 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { Platform } from "./platform.mjs";
+import { unsafeCast } from "./cast.mjs";
+import { listen } from "./listen.mjs";
+import { entryOf } from "./entry.mjs";
+import { fetchNextPage, fetchPreviousPage, getUnsafe as getUnsafe$1, hasNextPageUnsafe, hasPreviousPageUnsafe, refetch, subscribeUnsafe as subscribeUnsafe$1 } from "./query.mjs";
+import { Effect, Exit, FiberHandle, Pipeable, Predicate, Scope } from "effect";
 //#region src/observer.ts
+/**
+* One reader's view of one query at a time, as a data type, like TanStack
+* Query's `QueryObserver`: it derives the reader's result from the query's
+* state, keeps a previous query's data for `whilePending: "previous"`, runs
+* `refetchInterval`, and notifies its listeners only when a result property
+* they read changed (see {@link trackResult}). Bindings make one per hook.
+*
+* The `*Unsafe` functions read and update synchronously, for renders and
+* external stores. While it has listeners, the observer holds a `Scope` (a
+* child of its query's) that owns the query subscription and the polling
+* fiber; the last listener leaving, a switch to another query, or the query
+* leaving its cache closes it.
+*/
+var observer_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	changes: () => changes,
+	get: () => get,
+	getOptimisticResultUnsafe: () => getOptimisticResultUnsafe,
+	getUnsafe: () => getUnsafe,
+	isQueryObserver: () => isQueryObserver,
+	make: () => make,
+	makeUnsafe: () => makeUnsafe,
+	setOptionsUnsafe: () => setOptionsUnsafe,
+	subscribeUnsafe: () => subscribeUnsafe,
+	trackProp: () => trackProp,
+	trackResult: () => trackResult
+});
+const TypeId = "~@raf-query/core/QueryObserver";
+const Proto = {
+	...Pipeable.Prototype,
+	[TypeId]: { _A: (value) => value }
+};
 const resultKeys = {
 	error: true,
 	fetchNextPage: true,
@@ -18,150 +57,193 @@ const resultKeys = {
 	refetch: true,
 	updatedAt: true
 };
+function isQueryObserver(value) {
+	return Predicate.hasProperty(value, TypeId);
+}
+function implOf(self) {
+	return unsafeCast(self);
+}
 function isResultKey(name) {
-	return typeof name === "string" && Object.hasOwn(resultKeys, name);
+	return Predicate.isString(name) && Object.hasOwn(resultKeys, name);
 }
 function shallowEqual(a, b) {
 	for (const name of Object.keys(resultKeys)) if (isResultKey(name) && a[name] !== b[name]) return false;
 	return true;
 }
+/** The result for `query` with `options`, given the last query that had data. */
+function resultOf(query, options, lastWithData) {
+	const state = getUnsafe$1(query);
+	const previous = options.whilePending === "previous" && !state.hasData && state.status !== "error" && lastWithData !== void 0 && lastWithData.hash !== query.hash ? lastWithData : void 0;
+	const shown = previous ?? query;
+	const shownState = previous ? getUnsafe$1(previous) : state;
+	return {
+		error: state.error,
+		fetchNextPage: fetchNextPage(query),
+		fetchPreviousPage: fetchPreviousPage(query),
+		hash: query.hash,
+		hasNextPage: hasNextPageUnsafe(query),
+		hasPreviousPage: hasPreviousPageUnsafe(query),
+		input: shown.handle.input,
+		isFetching: state.isFetching,
+		isFetchingNextPage: state.fetchDirection === "forward",
+		isFetchingPreviousPage: state.fetchDirection === "backward",
+		isPending: !state.hasData,
+		isPrevious: previous !== void 0,
+		isStale: state.isStale,
+		key: shown.handle.key,
+		promise: shownState.promise,
+		refetch: refetch(query),
+		updatedAt: shownState.updatedAt
+	};
+}
+/** Observe `query`. Doesn't subscribe to it until the observer has a listener. */
+function makeUnsafe(query, options = {}) {
+	return Object.assign(Object.create(Proto), {
+		current: resultOf(query, options, void 0),
+		lastWithData: getUnsafe$1(query).hasData ? query : void 0,
+		listeners: /* @__PURE__ */ new Set(),
+		options,
+		query,
+		subscription: void 0,
+		trackedProps: /* @__PURE__ */ new Set()
+	});
+}
+/** {@link makeUnsafe}, as an Effect. */
+function make(query, options) {
+	return Effect.sync(() => makeUnsafe(query, options));
+}
+/** The current result. */
+function getUnsafe(self) {
+	return implOf(self).current;
+}
+/** {@link getUnsafe}, as an Effect. */
+function get(self) {
+	return Effect.sync(() => getUnsafe(self));
+}
 /**
-* One reader of one query at a time, like TanStack Query's `QueryObserver`:
-* it derives the reader's result from the query's state, keeps a previous
-* query's data for `whilePending: "previous"`, runs `refetchInterval`, and
-* notifies its listeners only when a result property they read changed
-* (see {@link QueryObserver.trackResult}). Bindings create one per hook.
+* The result for `query` with `options` right now, without switching to
+* them. Bindings call this during render, before `setOptionsUnsafe` commits.
 */
-var QueryObserver = class {
-	#current;
-	#interval;
-	#lastWithData;
-	#listeners = /* @__PURE__ */ new Set();
-	#options;
-	#query;
-	#trackedProps = /* @__PURE__ */ new Set();
-	#unsubscribe;
-	constructor(query, options = {}) {
-		this.#query = query;
-		this.#options = options;
-		this.#current = this.#createResult(query, options);
-		this.updateResult();
-	}
-	/**
-	* The result for `query` with `options` right now, without switching to
-	* it. Bindings call this during render, before `setOptions` commits.
-	*/
-	getOptimisticResult(query, options) {
-		const result = this.#createResult(query, options);
-		if (!shallowEqual(this.#current, result)) this.#current = result;
-		return result;
+function getOptimisticResultUnsafe(self, query, options) {
+	const impl = implOf(self);
+	const result = resultOf(query, options, impl.lastWithData);
+	if (!shallowEqual(impl.current, result)) impl.current = result;
+	return result;
+}
+/** Observe `query` with `options` from now on. */
+function setOptionsUnsafe(self, query, options) {
+	const impl = implOf(self);
+	const previous = impl.query;
+	const previousInterval = impl.options.refetchInterval;
+	impl.query = query;
+	impl.options = options;
+	if (impl.listeners.size > 0) {
+		if (query !== previous) connect(impl);
+		else if (options.refetchInterval !== previousInterval) restartPolling(impl);
 	}
-	getCurrentResult = () => this.#current;
-	/** Observe `query` with `options` from now on. */
-	setOptions(query, options) {
-		const previous = this.#query;
-		const previousInterval = this.#options.refetchInterval;
-		this.#query = query;
-		this.#options = options;
-		if (this.#listeners.size > 0) {
-			if (query !== previous) {
-				this.#unsubscribe?.();
-				this.#unsubscribe = this.#subscribeToQuery();
-			}
-			if (query !== previous || options.refetchInterval !== previousInterval) this.#startInterval();
-		}
-		this.updateResult();
+	updateResult(impl);
+}
+/** Listen for result changes. The first listener subscribes to the query. */
+function subscribeUnsafe(self, listener) {
+	const impl = implOf(self);
+	impl.listeners.add(listener);
+	if (!impl.subscription) {
+		connect(impl);
+		updateResult(impl);
 	}
-	/** Listen for result changes. The first listener subscribes to the query. */
-	subscribe = (listener) => {
-		this.#listeners.add(listener);
-		if (this.#listeners.size === 1) {
-			this.#unsubscribe = this.#subscribeToQuery();
-			this.#startInterval();
-			this.updateResult();
-		}
-		return () => {
-			if (!this.#listeners.delete(listener) || this.#listeners.size > 0) return;
-			this.#unsubscribe?.();
-			this.#unsubscribe = void 0;
-			clearInterval(this.#interval);
-		};
+	return () => {
+		if (!impl.listeners.delete(listener) || impl.listeners.size > 0) return;
+		disconnect(impl);
 	};
-	/**
-	* Wrap `result` so that reading a property marks it tracked. Once any
-	* property is tracked, listeners are only notified when a tracked one
-	* changes.
-	*/
-	trackResult(result) {
-		return new Proxy(result, { get: (target, name, receiver) => {
-			if (isResultKey(name)) this.trackProp(name);
-			return Reflect.get(target, name, receiver);
-		} });
-	}
-	/** Mark `name` as read, for bindings that track access themselves. */
-	trackProp(name) {
-		this.#trackedProps.add(name);
-	}
-	/** Recompute the result, and notify listeners if a tracked property changed. */
-	updateResult() {
-		const previous = this.#current;
-		const next = this.#createResult(this.#query, this.#options);
-		if (this.#query.getState().hasData) this.#lastWithData = this.#query;
-		if (shallowEqual(previous, next)) return;
-		this.#current = next;
-		if (this.#shouldNotify(previous, next)) for (const listener of this.#listeners) listener();
-	}
-	#shouldNotify(previous, next) {
-		if (this.#trackedProps.size === 0) return true;
-		for (const name of this.#trackedProps) if (previous[name] !== next[name]) return true;
-		return false;
-	}
-	#subscribeToQuery() {
-		const options = () => this.#options;
-		return this.#query.subscribe(() => this.updateResult(), {
-			get refetchOnReconnect() {
-				return options().refetchOnReconnect;
-			},
-			get refetchOnWindowFocus() {
-				return options().refetchOnWindowFocus;
+}
+/**
+* The current result, then every change listeners are notified of. Counts
+* as a listener while the stream runs, so the query counts as read.
+*/
+function changes(self) {
+	return listen((push) => {
+		let last;
+		const emit = () => {
+			const result = getUnsafe(self);
+			if (result !== last) {
+				last = result;
+				push(result);
 			}
-		});
-	}
-	#startInterval() {
-		clearInterval(this.#interval);
-		this.#interval = void 0;
-		const interval = this.#options.refetchInterval;
-		if (interval === void 0 || !Number.isFinite(interval) || interval <= 0) return;
-		this.#interval = setInterval(() => {
-			if (!("document" in globalThis) || document.visibilityState !== "hidden") this.#query.refetch();
-		}, interval);
-	}
-	#createResult(query, options) {
-		const state = query.getState();
-		const last = this.#lastWithData;
-		const previous = options.whilePending === "previous" && !state.hasData && state.status !== "error" && last !== void 0 && last.hash !== query.hash ? last : void 0;
-		const shown = previous ?? query;
-		const shownState = previous ? previous.getState() : state;
-		return {
-			error: state.error,
-			fetchNextPage: query.fetchNextPage,
-			fetchPreviousPage: query.fetchPreviousPage,
-			hash: query.hash,
-			hasNextPage: query.hasNextPage(),
-			hasPreviousPage: query.hasPreviousPage(),
-			input: shown.handle.input,
-			isFetching: state.isFetching,
-			isFetchingNextPage: state.fetchDirection === "forward",
-			isFetchingPreviousPage: state.fetchDirection === "backward",
-			isPending: !state.hasData,
-			isPrevious: previous !== void 0,
-			isStale: state.isStale,
-			key: shown.handle.key,
-			promise: shownState.promise,
-			refetch: query.refetch,
-			updatedAt: shownState.updatedAt
 		};
-	}
-};
+		const unsubscribe = subscribeUnsafe(self, emit);
+		emit();
+		return unsubscribe;
+	});
+}
+/**
+* Wrap `result` so that reading a property marks it tracked. Once any
+* property is tracked, listeners are only notified when a tracked one
+* changes.
+*/
+function trackResult(self, result) {
+	return new Proxy(result, { get: (target, name, receiver) => {
+		if (isResultKey(name)) trackProp(self, name);
+		return Reflect.get(target, name, receiver);
+	} });
+}
+/** Mark `name` as read, for bindings that track access themselves. */
+function trackProp(self, name) {
+	implOf(self).trackedProps.add(name);
+}
+/** Recompute the result, and notify listeners if a tracked property changed. */
+function updateResult(self) {
+	const previous = self.current;
+	const next = resultOf(self.query, self.options, self.lastWithData);
+	if (getUnsafe$1(self.query).hasData) self.lastWithData = self.query;
+	if (shallowEqual(previous, next)) return;
+	self.current = next;
+	if (shouldNotify(self, previous, next)) for (const listener of self.listeners) listener();
+}
+function shouldNotify(self, previous, next) {
+	if (self.trackedProps.size === 0) return true;
+	for (const name of self.trackedProps) if (previous[name] !== next[name]) return true;
+	return false;
+}
+/**
+* Subscribe to the current query in a new scope under its entry's, and
+* start polling. Replaces any previous subscription.
+*/
+function connect(self) {
+	disconnect(self);
+	const query = self.query;
+	const preferences = {
+		get refetchOnReconnect() {
+			return self.options.refetchOnReconnect;
+		},
+		get refetchOnWindowFocus() {
+			return self.options.refetchOnWindowFocus;
+		}
+	};
+	const scope = Scope.forkUnsafe(entryOf(query).scope);
+	self.subscription = {
+		polls: Effect.runSync(FiberHandle.make().pipe(Effect.tap(Effect.acquireRelease(Effect.sync(() => subscribeUnsafe$1(query, () => updateResult(self), preferences)), (unsubscribe) => Effect.sync(unsubscribe))), Scope.provide(scope))),
+		scope
+	};
+	restartPolling(self);
+}
+function disconnect(self) {
+	const subscription = self.subscription;
+	self.subscription = void 0;
+	if (subscription) Effect.runFork(Scope.close(subscription.scope, Exit.void));
+}
+/** Run `poll` for the current `refetchInterval`, or stop polling without one. */
+function restartPolling(self) {
+	const subscription = self.subscription;
+	if (!subscription) return;
+	const interval = self.options.refetchInterval;
+	const polls = subscription.polls;
+	Effect.runForkWith(entryOf(self.query).cache.services)(interval !== void 0 && Number.isFinite(interval) && interval > 0 ? FiberHandle.run(polls, poll(self.query, interval)) : FiberHandle.clear(polls));
+}
+/** Refetch `query` every `interval` ms while the page is visible. */
+function poll(query, interval) {
+	return Effect.gen(function* () {
+		if ((yield* Platform).isVisibleUnsafe()) yield* Effect.forkChild(refetch(query), { startImmediately: true });
+	}).pipe(Effect.delay(interval), Effect.forever);
+}
 //#endregion
-export { QueryObserver };
+export { TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, observer_exports, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult };

package/dist/options.d.mts

@@ -1,8 +1,12 @@
 import { QueryKey } from "./key.mjs";
 import { Effect, Schedule } from "effect";
 //#region src/options.d.ts
-/** What a `queryFn` may return: a value, a promise, or an `Effect`. */
-export type QueryFnResult<TData> = TData | PromiseLike<TData> | Effect.Effect<TData, unknown>;
+/**
+ * What a `queryFn` may return: a value, a promise, or an `Effect`. An
+ * Effect's error type becomes the query's (promises reject with `unknown`),
+ * and the services it needs become requirements of the verbs that start it.
+ */
+export type QueryFnResult<TData, TError = unknown, TServices = never> = TData | PromiseLike<TData> | Effect.Effect<TData, TError, TServices>;
 export interface QueryFunctionContext {
   /** The query's key, as returned by the factory. */
   readonly queryKey: QueryKey;
@@ -20,7 +24,7 @@ export interface PageFunctionContext<TPageParam> extends QueryFunctionContext {
  * of failures so far (1 after the first).
  */
 export type RetryPolicy = boolean | number | Schedule.Schedule<unknown, unknown> | ((failureCount: number, error: unknown) => boolean);
-/** Options every query accepts. `QueryClient` defaults fill in the rest. */
+/** Options every query accepts. `QueryCache` defaults fill in the rest. */
 export interface QueryBehavior {
   /** How long an unread entry stays cached, in ms. `Infinity` keeps it. */
   readonly gcTime?: number;
@@ -41,12 +45,21 @@ export interface QueryBehavior {
    */
   readonly structuralSharing?: boolean;
 }
-export interface QueryOptions<TData> extends QueryBehavior {
+declare const servicesType: unique symbol;
+interface ServicesField<TServices> {
+  /**
+   * Type-only: the services the `queryFn`'s Effect needs. Never present at
+   * runtime. A `queryFn`'s return type can't carry them on its own: with
+   * `unknown` data, any return type is assignable to `QueryFnResult`.
+   */
+  readonly [servicesType]?: () => TServices;
+}
+export interface QueryOptions<TData, TError = unknown, TServices = never> extends QueryBehavior, ServicesField<TServices> {
   readonly kind: "query";
-  queryFn(context: QueryFunctionContext): QueryFnResult<TData>;
+  queryFn(context: QueryFunctionContext): QueryFnResult<TData, TError, TServices>;
   readonly queryKey: QueryKey;
 }
-export interface InfiniteQueryOptions<TPage, TPageParam> extends QueryBehavior {
+export interface InfiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never> extends QueryBehavior, ServicesField<TServices> {
   /** Param for the page after `lastPage`, or `null` / `undefined` at the end. */
   getNextPageParam(lastPage: TPage, pages: ReadonlyArray<TPage>, lastPageParam: TPageParam, pageParams: ReadonlyArray<TPageParam>): TPageParam | null | undefined;
   /** Param for the page before `firstPage`, or `null` / `undefined` at the start. */
@@ -55,7 +68,7 @@ export interface InfiniteQueryOptions<TPage, TPageParam> extends QueryBehavior {
   readonly kind: "infinite";
   /** Keep at most this many pages; the far end is dropped when paging. */
   readonly maxPages?: number;
-  queryFn(context: PageFunctionContext<TPageParam>): QueryFnResult<TPage>;
+  queryFn(context: PageFunctionContext<TPageParam>): QueryFnResult<TPage, TError, TServices>;
   readonly queryKey: QueryKey;
 }
 /** Data of a paged query. */
@@ -63,7 +76,7 @@ export interface InfiniteData<TPage, TPageParam = unknown> {
   readonly pageParams: ReadonlyArray<TPageParam>;
   readonly pages: ReadonlyArray<TPage>;
 }
-export type AnyQueryOptions = QueryOptions<unknown> | InfiniteQueryOptions<unknown, unknown>;
+export type AnyQueryOptions = QueryOptions<unknown, unknown, unknown> | InfiniteQueryOptions<unknown, unknown, unknown, unknown>;
 /**
  * Typed options for a query factory:
  *
@@ -75,16 +88,28 @@ export type AnyQueryOptions = QueryOptions<unknown> | InfiniteQueryOptions<unkno
  *   });
  * }
  * ```
+ *
+ * A `queryFn` Effect may need services; they're inferred, and every verb
+ * that can start the query requires them.
  */
-export declare function queryOptions<TData>(options: Omit<QueryOptions<TData>, "kind">): QueryOptions<TData>;
+export declare function queryOptions<TData, TError = unknown, TServices = never>(options: Omit<QueryOptions<TData, TError, TServices>, "kind">): QueryOptions<TData, TError, TServices>;
 /** Typed options for a paged query factory. */
-export declare function infiniteQueryOptions<TPage, TPageParam>(options: Omit<InfiniteQueryOptions<TPage, TPageParam>, "kind">): InfiniteQueryOptions<TPage, TPageParam>;
+export declare function infiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never>(options: Omit<InfiniteQueryOptions<TPage, TPageParam, TError, TServices>, "kind">): InfiniteQueryOptions<TPage, TPageParam, TError, TServices>;
+interface FactoryResult {
+  readonly kind: "infinite" | "query";
+  readonly queryKey: QueryKey;
+}
 /**
  * A function of zero or one argument returning `queryOptions(...)` or
- * `infiniteQueryOptions(...)`. A second parameter is a type error: the single
+ * `infiniteQueryOptions(...)` whose `queryFn` needs at most `TServices`
+ * (any services by default). A second parameter is a type error: the single
  * argument is the query's input, and a handle carries it.
+ *
+ * The return type names no `queryFn`, and no services for the default:
+ * TypeScript infers an inline factory's `queryOptions` type arguments from
+ * it, and an `unknown` there would infer `unknown` services.
  */
-export type QueryFactory = (input: never) => AnyQueryOptions;
+export type QueryFactory<TServices = unknown> = (input: never) => unknown extends TServices ? FactoryResult : FactoryResult & ServicesField<TServices>;
 /** The factory's input type; `undefined` for factories without one. */
 export type InputOf<TFactory extends QueryFactory> = Parameters<TFactory> extends [] ? undefined : Parameters<TFactory>[0];
 /** Arguments after the factory: the input, optional when the factory's is. */
@@ -94,9 +119,20 @@ export type IsPaged<TFactory extends QueryFactory> = ReturnType<TFactory> extend
   readonly kind: "infinite";
 } ? true : false;
 /** The data a factory's query resolves to. */
-export type DataOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TPage, infer TPageParam> ? InfiniteData<TPage, TPageParam> : ReturnType<TFactory> extends QueryOptions<infer TData> ? TData : never;
+export type DataOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TPage, infer TPageParam, infer _TError, infer _TServices> ? InfiniteData<TPage, TPageParam> : ReturnType<TFactory> extends QueryOptions<infer TData, infer _TError, infer _TServices> ? TData : never;
+/**
+ * The error a factory's request fails with: the `queryFn`'s Effect error
+ * type, or `unknown` for promises and plain values.
+ */
+export type ErrorOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer _TPage, infer _TPageParam, infer TError, infer _TServices> ? TError : ReturnType<TFactory> extends QueryOptions<infer _TData, infer TError, infer _TServices> ? TError : unknown;
+/**
+ * The services a factory's `queryFn` Effect needs: what `ensure`, `fetch`,
+ * `prefetch`, `getQuery` and `watch` require. `never` for promises and plain
+ * values, and for a factory of no particular query.
+ */
+export type ServicesOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer _TPage, infer _TPageParam, infer _TError, infer TServices> ? TServices : ReturnType<TFactory> extends QueryOptions<infer _TData, infer _TError, infer TServices> ? TServices : never;
 /** Page type of a paged factory. */
-export type PageOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TPage, unknown> ? TPage : never;
+export type PageOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TPage, unknown, infer _TError, infer _TServices> ? TPage : never;
 /** `ensure` / `fetch` options. Only paged factories accept `pages`. */
 export type LoadOptions<TFactory extends QueryFactory> = IsPaged<TFactory> extends true ? {
   /** Load this many pages up front (default 1). */

package/dist/options.mjs

@@ -10,6 +10,9 @@
 *   });
 * }
 * ```
+*
+* A `queryFn` Effect may need services; they're inferred, and every verb
+* that can start the query requires them.
 */
 function queryOptions(options) {
 	return {

package/dist/platform.d.mts

@@ -0,0 +1,27 @@
+import { Context, Effect } from "effect";
+declare namespace platform_d_exports {
+  export { Platform, PlatformEvent, whenOnline };
+}
+/** `"focus"`: the page became visible. `"online"`: the browser reconnected. */
+export type PlatformEvent = "focus" | "online";
+/**
+ * The page a cache runs in: whether there is one, and its focus and network
+ * state. The default reads the global `window`, `document` and `navigator`;
+ * provide another to run a cache against a fake page.
+ */
+export interface Platform {
+  isOnlineUnsafe(): boolean;
+  /** No page to watch: a server render. */
+  readonly isServer: boolean;
+  isVisibleUnsafe(): boolean;
+  /** Call `listener` on every focus and reconnect until unsubscribed. */
+  subscribeUnsafe(listener: (event: PlatformEvent) => void): () => void;
+}
+export declare const Platform: Context.Reference<Platform>;
+/**
+ * Succeeds now if the platform is online, else on its next `"online"` event.
+ * Interrupting it unsubscribes.
+ */
+export declare const whenOnline: Effect.Effect<void>;
+//#endregion
+export { platform_d_exports };

package/dist/platform.mjs

@@ -0,0 +1,44 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { Context, Effect } from "effect";
+//#region src/platform.ts
+var platform_exports = /* @__PURE__ */ __exportAll({
+	Platform: () => Platform,
+	whenOnline: () => whenOnline
+});
+const globalPlatform = {
+	isOnlineUnsafe: () => !("window" in globalThis) || !("navigator" in globalThis) || !("onLine" in navigator) || navigator.onLine,
+	get isServer() {
+		return !("window" in globalThis);
+	},
+	isVisibleUnsafe: () => !("document" in globalThis) || document.visibilityState !== "hidden",
+	subscribeUnsafe(listener) {
+		if (!("window" in globalThis)) return () => {};
+		const onVisibilityChange = () => {
+			if (document.visibilityState === "visible") listener("focus");
+		};
+		const onOnline = () => listener("online");
+		window.addEventListener("visibilitychange", onVisibilityChange);
+		window.addEventListener("online", onOnline);
+		return () => {
+			window.removeEventListener("visibilitychange", onVisibilityChange);
+			window.removeEventListener("online", onOnline);
+		};
+	}
+};
+const Platform = Context.Reference("@raf-query/core/Platform", { defaultValue: () => globalPlatform });
+/**
+* Succeeds now if the platform is online, else on its next `"online"` event.
+* Interrupting it unsubscribes.
+*/
+const whenOnline = Effect.gen(function* () {
+	const platform = yield* Platform;
+	if (platform.isOnlineUnsafe()) return;
+	yield* Effect.callback((resume) => {
+		const unsubscribe = platform.subscribeUnsafe((event) => {
+			if (event === "online") resume(Effect.void);
+		});
+		return Effect.sync(unsubscribe);
+	});
+});
+//#endregion
+export { Platform, platform_exports, whenOnline };