@askrjs/askr 0.0.51 → 0.0.53

package/dist/resource-operation-CEzfpnDk.js

@@ -0,0 +1,276 @@
+import { t as enqueueRuntimeLane, v as logger } from "./access-Bg4RJNC8.js";
+import { d as getCurrentContextFrame, g as withAsyncResourceContext } from "./component-internal-B3z7GXlD.js";
+import { f as getCurrentComponentInstance } from "./component-scope-CC3cojX9.js";
+import { m as isPromiseLike, r as registerCommitOperationForInstance } from "./component-lifecycle-CO4hXlP4.js";
+import { t as brandSnapshotSource } from "./snapshot-source-BB42xgwb.js";
+import { i as getNextRenderKey, l as throwSSRDataMissing, n as getActiveRenderContext, r as getCurrentRenderData, u as SSRDataMissingError } from "./render-context-Clw3rFiO.js";
+import { t as state } from "./state-DPl8lffD.js";
+//#region src/runtime/resource-cell.ts
+/**
+* Pure, component-agnostic ResourceCell state machine.
+* - Holds value/pending/error/generation/controller
+* - Exposes a stable `snapshot` object: { value, pending, error, refresh }
+* - Uses `withAsyncResourceContext` to bind the synchronous execution step
+*   to a captured frame. Continuations after await do not see the frame.
+*/
+var ResourceCell = class {
+	constructor(fn, deps, resourceFrame) {
+		this.value = null;
+		this.pending = true;
+		this.error = null;
+		this.generation = 0;
+		this.controller = null;
+		this.deps = null;
+		this.resourceFrame = null;
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.disposed = false;
+		this.fn = fn;
+		this.deps = deps ? deps.slice() : null;
+		this.resourceFrame = resourceFrame;
+		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) cb();
+	}
+	start(ssr = false, notify = true) {
+		if (this.disposed) return;
+		const generation = this.generation;
+		this.controller?.abort();
+		const controller = new AbortController();
+		this.controller = controller;
+		this.pending = true;
+		this.error = null;
+		if (notify) this.notifySubscribers();
+		let result;
+		try {
+			result = withAsyncResourceContext(this.resourceFrame, () => this.fn({ signal: controller.signal }));
+		} catch (err) {
+			this.pending = false;
+			this.error = err instanceof Error ? err : new Error(String(err));
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (!isPromiseLike(result)) {
+			this.value = result;
+			this.pending = false;
+			this.error = null;
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (ssr) throwSSRDataMissing();
+		Promise.resolve(result).then((val) => {
+			if (this.generation !== generation) return;
+			if (this.controller !== controller) return;
+			if (controller.signal.aborted) return;
+			this.value = val;
+			this.pending = false;
+			this.error = null;
+			this.notifySubscribers();
+		}).catch((err) => {
+			if (this.generation !== generation) return;
+			if (this.controller !== controller) return;
+			if (controller.signal.aborted || err instanceof Error && err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError") return;
+			this.pending = false;
+			this.error = err instanceof Error ? err : new Error(String(err));
+			try {
+				if (this.ownerName) logger.error(`[Askr] Async resource error in ${this.ownerName}:`, err);
+				else logger.error("[Askr] Async resource error:", err);
+			} catch {}
+			this.notifySubscribers();
+		});
+	}
+	refresh() {
+		if (this.disposed) return;
+		this.generation++;
+		this.controller?.abort();
+		this.start();
+	}
+	abort() {
+		this.controller?.abort();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.controller?.abort();
+		this.subscribers.clear();
+	}
+};
+//#endregion
+//#region src/runtime/resource-operation.ts
+/**
+* Resource primitive — simple, deterministic async primitive
+* Usage: resource(fn, deps)
+* - fn receives { signal }
+* - captures execution context once at creation (synchronous step only)
+* - executes at most once per generation; stale async results are ignored
+* - refresh() cancels in-flight execution, increments generation and re-runs
+* - exposes { value, pending, error, refresh }
+* - during SSR, async results are disallowed and will throw synchronously
+*/
+function resource(fn, deps = []) {
+	const instance = getCurrentComponentInstance();
+	const inst = instance;
+	if (!instance) {
+		const renderData = getCurrentRenderData()?.resources;
+		if (renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:")))) {
+			const key = getNextRenderKey();
+			if (!(key in renderData)) throwSSRDataMissing();
+			const val = renderData[key];
+			return brandSnapshotSource({
+				value: val,
+				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.");
+	}
+	const renderData = getCurrentRenderData()?.resources;
+	if (renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:")))) {
+		const key = getNextRenderKey();
+		if (!(key in renderData)) throwSSRDataMissing();
+		const val = renderData[key];
+		const h = state({
+			cell: void 0,
+			snapshot: brandSnapshotSource({
+				value: val,
+				pending: false,
+				error: null,
+				refresh: () => {}
+			})
+		})();
+		h.snapshot.value = val;
+		h.snapshot.pending = false;
+		h.snapshot.error = null;
+		return h.snapshot;
+	}
+	const holder = state({
+		cell: void 0,
+		snapshot: brandSnapshotSource({
+			value: null,
+			pending: true,
+			error: null,
+			refresh: () => {}
+		})
+	});
+	const h = holder();
+	if (!h.cell) {
+		const cell = new ResourceCell(fn, deps, getCurrentContextFrame());
+		cell.ownerName = inst.fn?.name || "<anonymous>";
+		h.cell = cell;
+		h.snapshot = cell.snapshot;
+		const unsubscribe = cell.subscribe(() => {
+			const cur = holder();
+			cur.snapshot.value = cell.snapshot.value;
+			cur.snapshot.pending = cell.snapshot.pending;
+			cur.snapshot.error = cell.snapshot.error;
+			holder.set(cur);
+			try {
+				inst.notifyUpdate?.();
+			} catch {}
+		});
+		(inst.cleanupFns ??= []).push(() => {
+			unsubscribe();
+			cell.dispose();
+		});
+		if (inst.ssr) {
+			cell.start(true, false);
+			if (!cell.pending) {
+				const cur = holder();
+				cur.snapshot.value = cell.value;
+				cur.snapshot.pending = cell.pending;
+				cur.snapshot.error = cell.error;
+			}
+		} else {
+			const scheduledGeneration = cell.generation;
+			registerCommitOperationForInstance(inst, () => {
+				enqueueRuntimeLane("post", () => {
+					if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+					try {
+						cell.start(false, false);
+					} catch (err) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = err ?? null;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+						return;
+					}
+					if (!cell.pending) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = cell.error;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+					}
+				});
+			});
+		}
+	}
+	const cell = h.cell;
+	cell.setLoader(fn);
+	if (!cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => !Object.is(d, deps[i]))) {
+		cell.deps = deps.slice();
+		cell.generation++;
+		cell.pending = true;
+		cell.error = null;
+		h.snapshot.pending = true;
+		h.snapshot.error = null;
+		try {
+			if (inst.ssr) {
+				cell.start(true, false);
+				if (!cell.pending) {
+					const cur = holder();
+					cur.snapshot.value = cell.value;
+					cur.snapshot.pending = cell.pending;
+					cur.snapshot.error = cell.error;
+				}
+			} else {
+				const scheduledGeneration = cell.generation;
+				registerCommitOperationForInstance(inst, () => {
+					enqueueRuntimeLane("post", () => {
+						if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+						cell.start(false, false);
+						if (!cell.pending) {
+							const cur = holder();
+							cur.snapshot.value = cell.value;
+							cur.snapshot.pending = cell.pending;
+							cur.snapshot.error = cell.error;
+							holder.set(cur);
+							inst.notifyUpdate?.();
+						}
+					});
+				});
+			}
+		} catch (err) {
+			if (err instanceof SSRDataMissingError) throw err;
+			cell.error = err;
+			cell.pending = false;
+			const cur = holder();
+			cur.snapshot.value = cell.value;
+			cur.snapshot.pending = cell.pending;
+			cur.snapshot.error = cell.error;
+		}
+	}
+	return h.snapshot;
+}
+//#endregion
+export { resource as t };

package/dist/resources/index.d.ts

@@ -1,4 +1,43 @@
-import { getSignal } from "../runtime/component-scope.js";
-import { ResourceResult, resource } from "../runtime/resource-operation.js";
-import { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "../runtime/lifecycle-operations.js";
+import { t as getSignal } from "../component-scope-CvPba6O6.js";
+
+//#region src/runtime/resource-operation.d.ts
+interface ResourceResult<T> {
+  value: T | null;
+  pending: boolean;
+  error: Error | null;
+  refresh(): void;
+}
+declare function resource<T, const TDeps extends readonly unknown[]>(fn: (opts: {
+  signal: AbortSignal;
+}) => PromiseLike<T> | T, deps: TDeps): ResourceResult<T>;
+//#endregion
+//#region src/runtime/lifecycle-operations.d.ts
+type ActivityPredicate = () => boolean;
+interface TimerOptions {
+  when?: ActivityPredicate | readonly ActivityPredicate[];
+}
+declare function routeActive(pathOrPaths: string | readonly string[]): ActivityPredicate;
+declare function documentVisible(): ActivityPredicate;
+declare function windowFocused(): ActivityPredicate;
+type ListenerOptions = boolean | AddEventListenerOptions | undefined;
+declare function on(target: EventTarget, event: string, handler: EventListener, options?: ListenerOptions): void;
+declare function timer(intervalMs: number, fn: () => void, options?: TimerOptions): void;
+declare function stream<T>(_source: unknown, _options?: Record<string, unknown>): {
+  value: T | null;
+  pending: boolean;
+  error: Error | null;
+};
+declare function task(fn: () => void | (() => void) | PromiseLike<void | (() => void)>): void;
+/**
+ * Capture the result of a synchronous expression at call time and return a
+ * thunk that returns the captured value later. This is a low-level helper for
+ * cases where async continuations need to observe a snapshot of values at the
+ * moment scheduling occurred.
+ *
+ * Usage (public API):
+ * const snapshot = capture(() => someState());
+ * Promise.resolve().then(() => { use(snapshot()); });
+ */
+declare function capture<T>(fn: () => T): () => T;
+//#endregion
 export { type ActivityPredicate, type ResourceResult, type TimerOptions, capture, documentVisible, getSignal, on, resource, routeActive, stream, task, timer, windowFocused };

package/dist/resources/index.js

@@ -1,5 +1,4 @@
-import { getSignal } from "../runtime/component-scope.js";
-import { resource } from "../runtime/resource-operation.js";
-import { capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "../runtime/lifecycle-operations.js";
-import "../runtime/index.js";
+import { g as getSignal } from "../component-scope-CC3cojX9.js";
+import { t as resource } from "../resource-operation-CEzfpnDk.js";
+import { a as stream, c as windowFocused, i as routeActive, n as documentVisible, o as task, r as on, s as timer, t as capture } from "../lifecycle-operations-D9va7GOU.js";
 export { capture, documentVisible, getSignal, on, resource, routeActive, stream, task, timer, windowFocused };

package/dist/{common/route-activity.js → route-activity-CNJfpwx-.js}

@@ -25,6 +25,4 @@ function isRouteActivityActive(pathOrPaths) {
 	return currentRouteActivity.matches.some((match) => candidates.has(normalizeRouteActivityPath(match.path)));
 }
 //#endregion
-export { isRouteActivityActive, syncRouteActivitySnapshot };
-
-//# sourceMappingURL=route-activity.js.map
+export { syncRouteActivitySnapshot as n, isRouteActivityActive as t };