@askrjs/askr 0.0.52 → 0.0.53

package/dist/{runtime/resource-operation.js → resource-operation-CEzfpnDk.js}

@@ -1,13 +1,116 @@
-import { enqueueRuntimeLane } from "./access.js";
-import { getCurrentContextFrame } from "./context.js";
-import { getCurrentComponentInstance } from "./component-scope.js";
-import { registerCommitOperationForInstance } from "./component-lifecycle.js";
-import "./component.js";
-import { brandSnapshotSource } from "./snapshot-source.js";
-import { SSRDataMissingError } from "../common/ssr-errors.js";
-import { getActiveRenderContext, getCurrentRenderData, getNextRenderKey, throwSSRDataMissing } from "../common/render-context.js";
-import { ResourceCell } from "./resource-cell.js";
-import { state } from "./state.js";
+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
@@ -23,8 +126,8 @@ function resource(fn, deps = []) {
 	const instance = getCurrentComponentInstance();
 	const inst = instance;
 	if (!instance) {
-		const renderData = getCurrentRenderData();
-		if (renderData) {
+		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];
@@ -38,8 +141,8 @@ function resource(fn, deps = []) {
 		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();
-	if (renderData) {
+	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];
@@ -170,4 +273,4 @@ function resource(fn, deps = []) {
 	return h.snapshot;
 }
 //#endregion
-export { resource };
+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,4 +25,4 @@ function isRouteActivityActive(pathOrPaths) {
 	return currentRouteActivity.matches.some((match) => candidates.has(normalizeRouteActivityPath(match.path)));
 }
 //#endregion
-export { isRouteActivityActive, syncRouteActivitySnapshot };
+export { syncRouteActivitySnapshot as n, isRouteActivityActive as t };