@askrjs/askr 0.3.0 → 0.4.0

package/dist/resource-CLjB7RBQ.js

@@ -0,0 +1,377 @@
+import { A as untrack, F as logger, N as runWithOwner, S as queueTask, d as recordUndo } from "./instance-BAnfmXOR.js";
+import { t as brandSnapshotSource } from "./snapshot-Cjx4N988.js";
+import { c as onCommit, i as currentComponent, n as createSource, o as hookSlot, r as currentAppRuntime, s as notify, u as readSource } from "./hooks-BimKStr4.js";
+import { T as SSRDataMissingError, a as getResourceVerificationSnapshot, h as throwSSRDataMissing, i as getNextRenderKey, n as getActiveRenderContext, o as isHydrationVerificationRender, r as getCurrentRenderData, s as recordResourceVerificationSnapshot } from "./render-context-DGHnEveC.js";
+import { n as isPromiseLike } from "./promise-Dz8iIHAm.js";
+//#region src/core/api/resource-cell.ts
+/**
+* Pure, component-agnostic ResourceCell state machine.
+* - Holds value/pending/error/generation/controller
+* - Exposes a stable `snapshot` object: { value, pending, error, refresh }
+* - Runs the loader's synchronous step under the owner that created it, so
+*   it can read scopes; continuations after await do not.
+*/
+var ResourceCell = class {
+	constructor(fn, deps, owner) {
+		this.value = null;
+		this.pending = true;
+		this.error = null;
+		this.generation = 0;
+		this.controller = null;
+		this.deps = null;
+		this.owner = null;
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.disposed = false;
+		this.fn = fn;
+		this.deps = deps ? deps.slice() : null;
+		this.owner = owner;
+		this.snapshot = brandSnapshotSource({
+			value: null,
+			pending: true,
+			error: null,
+			refresh: () => this.refresh()
+		});
+	}
+	setLoader(fn) {
+		this.fn = fn;
+	}
+	subscribe(cb) {
+		this.subscribers.add(cb);
+		return () => this.subscribers.delete(cb);
+	}
+	notifySubscribers() {
+		this.snapshot.value = this.value;
+		this.snapshot.pending = this.pending;
+		this.snapshot.error = this.error;
+		for (const cb of this.subscribers) try {
+			cb();
+		} catch (error) {
+			this.reportError(error, "Resource subscriber error");
+		}
+	}
+	reportError(error, label = "Async resource error") {
+		try {
+			logger.error(`[Askr] ${label}${this.ownerName ? ` in ${this.ownerName}` : ""}:`, error);
+		} catch {}
+	}
+	start(ssr = false, notify = true) {
+		if (this.disposed) return;
+		const generation = this.generation;
+		const previous = this.controller;
+		const controller = new AbortController();
+		this.controller = controller;
+		const current = () => this.generation === generation && this.controller === controller && !controller.signal.aborted;
+		previous?.abort();
+		if (!current()) return;
+		this.pending = true;
+		this.error = null;
+		if (notify) this.notifySubscribers();
+		if (!current()) return;
+		const fail = (reason, asynchronous = false) => {
+			if (!current()) return;
+			let error;
+			try {
+				if (asynchronous && (reason instanceof Error && reason.name === "AbortError" || typeof DOMException !== "undefined" && reason instanceof DOMException && reason.name === "AbortError")) return;
+				error = reason instanceof Error ? reason : new Error(String(reason));
+			} catch {
+				error = /* @__PURE__ */ new Error("Resource error normalization failed");
+			}
+			if (!current()) return;
+			this.pending = false;
+			this.error = error;
+			if (asynchronous) this.reportError(reason);
+			if (current() && (notify || asynchronous)) this.notifySubscribers();
+		};
+		let result;
+		let asynchronous;
+		try {
+			result = untrack(() => runWithOwner(this.owner, () => this.fn({ signal: controller.signal })));
+			asynchronous = isPromiseLike(result);
+		} catch (err) {
+			fail(err);
+			return;
+		}
+		if (!asynchronous) {
+			if (!current()) return;
+			this.value = result;
+			this.pending = false;
+			this.error = null;
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (ssr) {
+			new Promise((resolve) => resolve(result)).then(void 0, () => {});
+			controller.abort();
+			throwSSRDataMissing();
+		}
+		try {
+			Promise.resolve(result).then((val) => {
+				if (!current()) return;
+				this.value = val;
+				this.pending = false;
+				this.error = null;
+				this.notifySubscribers();
+			}, (err) => fail(err, true));
+		} catch (err) {
+			fail(err);
+		}
+	}
+	refresh() {
+		if (this.disposed) return;
+		this.generation++;
+		this.start();
+	}
+	abort() {
+		this.controller?.abort();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.controller?.abort();
+		this.subscribers.clear();
+	}
+};
+//#endregion
+//#region src/core/api/resource.ts
+/**
+* resource(): component-owned async data with cancellation and refresh.
+*
+* The loader starts after the render that declared it commits (never during
+* render on the client). Its state lives in a stable snapshot object; the
+* component reads a readable source alongside it, so a published result
+* re-renders exactly the components that read the snapshot. On the server
+* the loader must be synchronous or preloaded; SSR render keys align server
+* values with hydration.
+*/
+function hydrationVerificationSnapshot() {
+	return brandSnapshotSource({
+		value: null,
+		pending: true,
+		error: null,
+		refresh: () => {}
+	});
+}
+/**
+* What resource data, if any, the current render was given.
+*
+* Both the outside-a-component path and the in-component path asked this
+* question, each spelling out the same two-part test by hand. One answer keeps
+* the "is this a hydrating render with preloaded values" decision from drifting
+* between them.
+*/
+function resolveResourceRenderData(useRuntimeResources) {
+	const renderData = getCurrentRenderData()?.resources ?? (useRuntimeResources ? currentAppRuntime()?.hydrationResources : void 0);
+	return {
+		renderData,
+		hasPreloadedData: Boolean(renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:"))))
+	};
+}
+/**
+* Resolve a resource declared outside any component instance.
+*
+* Only legitimate during a synchronous SSR render that already carries resolved
+* data; every other caller is creating a resource where it cannot be owned.
+*/
+function resolveResourceWithoutInstance() {
+	const { renderData, hasPreloadedData } = resolveResourceRenderData(false);
+	if (renderData && hasPreloadedData) {
+		const key = getNextRenderKey();
+		if (!(key in renderData)) throwSSRDataMissing();
+		return brandSnapshotSource({
+			value: renderData[key],
+			pending: false,
+			error: null,
+			refresh: () => {}
+		});
+	}
+	if (getActiveRenderContext()) throwSSRDataMissing();
+	throw new Error("[Askr] resource() must be called during component render inside an app. Do not create resources at module scope or outside render.");
+}
+function resource(sourceOrLoader, depsOrLoader) {
+	if (typeof depsOrLoader === "function") {
+		if (!currentComponent()) return resolveResourceWithoutInstance();
+		const source = sourceOrLoader;
+		const load = depsOrLoader;
+		const value = source();
+		return createResource(({ signal }) => load(value, { signal }), [value]);
+	}
+	return createResource(sourceOrLoader, depsOrLoader ?? []);
+}
+/** Restore render-time snapshot edits when the render transaction is discarded. */
+function journalSnapshot(snapshot) {
+	const previous = {
+		value: snapshot.value,
+		pending: snapshot.pending,
+		error: snapshot.error
+	};
+	recordUndo(() => {
+		snapshot.value = previous.value;
+		snapshot.pending = previous.pending;
+		snapshot.error = previous.error;
+	});
+}
+function createResource(fn, deps = []) {
+	const instance = currentComponent();
+	if (!instance) return resolveResourceWithoutInstance();
+	const inst = instance;
+	const { renderData, hasPreloadedData: hasPreloadedResourceData } = resolveResourceRenderData(inst.hydrationResourceKeys !== null);
+	const componentKey = inst.hydrationResourceKeys === null ? void 0 : inst.hydrationResourceKeys[inst.hydrationResourceIndex++];
+	if (inst.hydrationResourceKeys !== null && !componentKey) throwSSRDataMissing();
+	const renderKey = componentKey ?? (inst.server || hasPreloadedResourceData ? getNextRenderKey() : null);
+	if (inst.server && renderKey) inst.serverResourceKeys.push(renderKey);
+	const verificationSnapshot = renderKey ? getResourceVerificationSnapshot(renderKey, getCurrentRenderData()?.framework ?? (inst.hydrationResourceKeys !== null ? currentAppRuntime()?.framework : void 0)) : null;
+	const preloaded = renderData && hasPreloadedResourceData && renderKey && renderKey in renderData ? {
+		value: renderData[renderKey],
+		pending: false
+	} : null;
+	if (!preloaded && isHydrationVerificationRender() && verificationSnapshot) {
+		const result = hydrationVerificationSnapshot();
+		result.value = verificationSnapshot.value;
+		result.pending = verificationSnapshot.pending;
+		return result;
+	}
+	if (!preloaded && renderData && hasPreloadedResourceData && renderKey && (inst.server || !verificationSnapshot)) throwSSRDataMissing();
+	const ssrRenderKey = inst.server ? renderKey : null;
+	let seed = null;
+	if (preloaded) seed = preloaded;
+	else if (!inst.server && verificationSnapshot) seed = {
+		value: verificationSnapshot.value,
+		pending: verificationSnapshot.pending
+	};
+	const h = hookSlot(inst, "resource", () => ({
+		cell: void 0,
+		uncommittedDeps: false,
+		source: createSource(),
+		snapshot: brandSnapshotSource({
+			value: seed ? seed.value : null,
+			pending: seed?.pending ?? true,
+			error: null,
+			refresh: () => {}
+		})
+	}));
+	readSource(h.source);
+	const publish = () => notify(h.source);
+	if (!h.cell) {
+		const cell = new ResourceCell(fn, deps, inst);
+		if (seed) {
+			cell.value = seed.value;
+			cell.pending = seed.pending;
+			cell.snapshot.value = seed.value;
+			cell.snapshot.pending = seed.pending;
+		}
+		cell.ownerName = inst.displayName || "<anonymous>";
+		h.cell = cell;
+		h.snapshot = cell.snapshot;
+		const unsubscribe = cell.subscribe(() => {
+			h.snapshot.value = cell.snapshot.value;
+			h.snapshot.pending = cell.snapshot.pending;
+			h.snapshot.error = cell.snapshot.error;
+			publish();
+		});
+		inst.onCleanup(unsubscribe);
+		inst.onCleanup(() => cell.dispose());
+		if (!preloaded && inst.server) {
+			cell.start(true, false);
+			if (!cell.pending) {
+				h.snapshot.value = cell.value;
+				h.snapshot.pending = cell.pending;
+				h.snapshot.error = cell.error;
+			}
+			if (ssrRenderKey && cell.value === null && cell.error === null) recordResourceVerificationSnapshot(ssrRenderKey, {
+				value: null,
+				pending: cell.pending
+			});
+		} else if (!preloaded) {
+			const scheduledGeneration = cell.generation;
+			onCommit(inst, () => {
+				queueTask(() => {
+					if (inst.disposed || cell.generation !== scheduledGeneration) return;
+					try {
+						cell.start(false, false);
+					} catch (err) {
+						h.snapshot.value = cell.value;
+						h.snapshot.pending = cell.pending;
+						h.snapshot.error = err ?? null;
+						publish();
+						return;
+					}
+					if (!cell.pending) {
+						h.snapshot.value = cell.value;
+						h.snapshot.pending = cell.pending;
+						h.snapshot.error = cell.error;
+						publish();
+					}
+				});
+			});
+		}
+	}
+	const cell = h.cell;
+	if (!cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => !Object.is(d, deps[i]))) {
+		journalSnapshot(h.snapshot);
+		h.snapshot.pending = true;
+		h.snapshot.error = null;
+		try {
+			if (inst.server) {
+				cell.setLoader(fn);
+				cell.deps = deps.slice();
+				cell.generation++;
+				cell.pending = true;
+				cell.error = null;
+				cell.start(true, false);
+				if (!cell.pending) {
+					h.snapshot.value = cell.value;
+					h.snapshot.pending = cell.pending;
+					h.snapshot.error = cell.error;
+				}
+			} else {
+				const nextDeps = deps.slice();
+				const hadUncommittedDeps = h.uncommittedDeps;
+				h.uncommittedDeps = true;
+				recordUndo(() => {
+					h.uncommittedDeps = hadUncommittedDeps;
+				});
+				onCommit(inst, () => {
+					h.uncommittedDeps = false;
+					cell.setLoader(fn);
+					cell.deps = nextDeps;
+					cell.generation++;
+					cell.pending = true;
+					cell.error = null;
+					const scheduledGeneration = cell.generation;
+					queueTask(() => {
+						if (inst.disposed || cell.generation !== scheduledGeneration) return;
+						cell.start(false, false);
+						if (!cell.pending) {
+							h.snapshot.value = cell.value;
+							h.snapshot.pending = cell.pending;
+							h.snapshot.error = cell.error;
+							publish();
+						}
+					});
+				});
+			}
+		} catch (err) {
+			if (err instanceof SSRDataMissingError) throw err;
+			cell.error = err;
+			cell.pending = false;
+			h.snapshot.value = cell.value;
+			h.snapshot.pending = cell.pending;
+			h.snapshot.error = cell.error;
+		}
+	} else {
+		onCommit(inst, () => cell.setLoader(fn));
+		if (h.uncommittedDeps) {
+			const hadUncommittedDeps = h.uncommittedDeps;
+			journalSnapshot(h.snapshot);
+			h.uncommittedDeps = false;
+			recordUndo(() => {
+				h.uncommittedDeps = hadUncommittedDeps;
+			});
+			h.snapshot.pending = cell.pending;
+			h.snapshot.error = cell.error;
+		}
+	}
+	return h.snapshot;
+}
+//#endregion
+export { resource as t };

package/dist/resources/index.d.ts

@@ -11,16 +11,10 @@ import {
   documentVisible,
   task,
   watch,
-  getSignal,
   WatchContext,
   windowFocused,
   timer,
 } from '../core.js';
-import {
-  onRouteChange,
-  RouteChangeOptions,
-  RouteChangeCleanup,
-} from '../route-activity.js';
 /** Reactive result of a {@link resource}: current value, loading state, and controls. */
 interface ResourceResult<T> {
   value: T | null;
@@ -28,11 +22,22 @@ interface ResourceResult<T> {
   error: Error | null;
   refresh(): void;
 }
+/** Create a source-driven resource whose loader receives the latest source value. */
+declare function resource<TSource, T>(
+  source: () => TSource,
+  load: (value: TSource, opts: { signal: AbortSignal }) => PromiseLike<T> | T
+): ResourceResult<T>;
 /** Creates a render-scoped async resource with cancellation and refresh; SSR has special data rules. */
-declare function resource<T, const TDeps extends readonly unknown[]>(
+declare function resource<
+  T,
+  const TDeps extends readonly unknown[] = readonly unknown[],
+>(
   fn: (opts: { signal: AbortSignal }) => PromiseLike<T> | T,
   deps: TDeps
 ): ResourceResult<T>;
+declare function resource<T>(
+  fn: (opts: { signal: AbortSignal }) => PromiseLike<T> | T
+): ResourceResult<T>;
 /** Connection status of a {@link stream}. */
 type StreamStatus =
   | 'connecting'
@@ -58,6 +63,15 @@ interface StreamOptions<T> {
 type StreamSource<T> = (context: {
   signal: AbortSignal;
 }) => AsyncIterable<T> | PromiseLike<AsyncIterable<T>>;
+/** Connect a stream from an input read during a positional component render. */
+declare function stream<TSource, T>(
+  source: () => TSource,
+  connect: (
+    value: TSource,
+    context: { signal: AbortSignal }
+  ) => AsyncIterable<T> | PromiseLike<AsyncIterable<T>>,
+  options?: Omit<StreamOptions<T>, 'deps'>
+): StreamResult<T>;
 /** Subscribe to a streaming data source for the current component's lifetime, with auto reconnect/cleanup. */
 declare function stream<T>(
   source: StreamSource<T>,
@@ -67,8 +81,6 @@ export {
   type ActivityPredicate,
   type ListenerTarget,
   type ResourceResult,
-  type RouteChangeCleanup,
-  type RouteChangeOptions,
   type StreamOptions,
   type StreamResult,
   type StreamStatus,
@@ -79,9 +91,7 @@ export {
   type WatchValues,
   capture,
   documentVisible,
-  getSignal,
   on,
-  onRouteChange,
   resource,
   routeActive,
   stream,