@askrjs/askr 0.0.70 → 0.0.71

package/dist/resources/index.d.ts

@@ -1,4 +1,5 @@
-import { t as getSignal } from "../component-scope-CvPba6O6.js";
+import { h as getSignal } from "../index-BOBtoY_r.js";
+import { i as onRouteChange, n as RouteChangeOptions, t as RouteChangeCleanup } from "../activity-DZ-NCYr8.js";
 //#region src/runtime/resource-operation.d.ts
 interface ResourceResult<T> {
   value: T | null;
@@ -6,10 +7,31 @@ interface ResourceResult<T> {
   error: Error | null;
   refresh(): void;
 }
+/** Creates a render-scoped async resource with cancellation and refresh; SSR has special data rules. */
 declare function resource<T, const TDeps extends readonly unknown[]>(fn: (opts: {
   signal: AbortSignal;
 }) => PromiseLike<T> | T, deps: TDeps): ResourceResult<T>;
 //#endregion
+//#region src/runtime/stream-operation.d.ts
+type StreamStatus = 'connecting' | 'connected' | 'reconnecting' | 'closed' | 'error';
+interface StreamResult<T> {
+  value: T | null;
+  status: StreamStatus;
+  pending: boolean;
+  stale: boolean;
+  error: Error | null;
+  restart(): void;
+  close(): void;
+}
+interface StreamOptions<T> {
+  deps?: readonly unknown[];
+  initialValue?: T;
+}
+type StreamSource<T> = (context: {
+  signal: AbortSignal;
+}) => AsyncIterable<T> | PromiseLike<AsyncIterable<T>>;
+declare function stream<T>(source: StreamSource<T>, options?: StreamOptions<T>): StreamResult<T>;
+//#endregion
 //#region src/runtime/lifecycle-operations.d.ts
 type ActivityPredicate = () => boolean;
 interface TimerOptions {
@@ -18,14 +40,11 @@ interface TimerOptions {
 declare function routeActive(pathOrPaths: string | readonly string[]): ActivityPredicate;
 declare function documentVisible(): ActivityPredicate;
 declare function windowFocused(): ActivityPredicate;
+type ListenerTarget = EventTarget | (() => EventTarget | null | undefined);
 type ListenerOptions = boolean | AddEventListenerOptions | undefined;
-declare function on(target: EventTarget, event: string, handler: EventListener, options?: ListenerOptions): void;
+declare function on(target: ListenerTarget, 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;
-};
+/** Runs an owned task after commit. */
 declare function task(fn: () => void | (() => void) | PromiseLike<void | (() => void)>): void;
 /**
  * Capture the result of a synchronous expression at call time and return a
@@ -39,4 +58,4 @@ declare function task(fn: () => void | (() => void) | PromiseLike<void | (() =>
  */
 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 };
+export { type ActivityPredicate, type ListenerTarget, type ResourceResult, type RouteChangeCleanup, type RouteChangeOptions, type StreamOptions, type StreamResult, type StreamStatus, type TimerOptions, capture, documentVisible, getSignal, on, onRouteChange, resource, routeActive, stream, task, timer, windowFocused };

package/dist/resources/index.js

@@ -1,4 +1,218 @@
-import { g as getSignal } from "../component-scope-CC3cojX9.js";
-import { t as resource } from "../resource-operation-BJiLoLYZ.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-SlPEK68H.js";
-export { capture, documentVisible, getSignal, on, resource, routeActive, stream, task, timer, windowFocused };
+import { t as enqueueRuntimeLane } from "../access-ePqdQqkV.js";
+import { a as registerCommitOperation } from "../component-internal-CPjM4n8M.js";
+import { f as getCurrentComponentInstance, g as getSignal, i as claimHookIndex } from "../component-scope-CC3cojX9.js";
+import { z as resource } from "../route-matching-M-f1VQRu.js";
+import { a as task, i as routeActive, n as documentVisible, o as timer, r as on, s as windowFocused, t as capture } from "../lifecycle-operations-Db-_MG-O.js";
+import { n as onRouteChange } from "../activity-C2tPn9Fr.js";
+//#region src/runtime/stream-operation.ts
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+function depsEqual(left, right) {
+	return left.length === right.length && left.every((value, index) => Object.is(value, right[index]));
+}
+function publish(slot) {
+	if (slot.disposed) return;
+	try {
+		slot.owner?.notifyUpdate?.();
+	} catch {}
+}
+function setStartingState(slot) {
+	const retained = slot.hasValue;
+	slot.snapshot.status = retained && slot.generation > 0 ? "reconnecting" : "connecting";
+	slot.snapshot.pending = !retained;
+	slot.snapshot.stale = retained;
+	slot.snapshot.error = null;
+}
+function returnIterator(generation) {
+	if (generation.returned || !generation.iterator) return;
+	generation.returned = true;
+	const returnMethod = generation.iterator.return;
+	if (typeof returnMethod !== "function") return;
+	try {
+		Promise.resolve(returnMethod.call(generation.iterator)).catch(() => {});
+	} catch {}
+}
+function stopGeneration(generation) {
+	if (!generation || generation.stopped) return;
+	generation.stopped = true;
+	generation.controller.abort();
+	returnIterator(generation);
+}
+function isCurrent(slot, generation) {
+	return !slot.disposed && !generation.stopped && slot.current === generation && slot.generation === generation.id;
+}
+async function consume(slot, generation, iterable) {
+	const iteratorFactory = iterable?.[Symbol.asyncIterator];
+	if (typeof iteratorFactory !== "function") throw new TypeError("stream() source must return an AsyncIterable.");
+	const iterator = iteratorFactory.call(iterable);
+	if (!iterator || typeof iterator.next !== "function") throw new TypeError("stream() source must return an AsyncIterable with an iterator.");
+	generation.iterator = iterator;
+	if (!isCurrent(slot, generation)) {
+		returnIterator(generation);
+		return;
+	}
+	while (isCurrent(slot, generation)) {
+		const step = await iterator.next();
+		if (!isCurrent(slot, generation)) return;
+		if (step.done) {
+			slot.current = null;
+			slot.snapshot.status = "closed";
+			slot.snapshot.pending = false;
+			slot.snapshot.stale = slot.hasValue;
+			slot.snapshot.error = null;
+			publish(slot);
+			return;
+		}
+		slot.snapshot.value = step.value;
+		slot.hasValue = true;
+		slot.snapshot.status = "connected";
+		slot.snapshot.pending = false;
+		slot.snapshot.stale = false;
+		slot.snapshot.error = null;
+		publish(slot);
+	}
+}
+function startSlot(slot) {
+	if (!slot.activated || slot.disposed) return;
+	stopGeneration(slot.current);
+	slot.explicitlyClosed = false;
+	setStartingState(slot);
+	publish(slot);
+	const generation = {
+		id: ++slot.generation,
+		controller: new AbortController(),
+		iterator: null,
+		returned: false,
+		stopped: false
+	};
+	slot.current = generation;
+	let result;
+	try {
+		result = slot.source({ signal: generation.controller.signal });
+	} catch (error) {
+		if (!isCurrent(slot, generation)) return;
+		slot.current = null;
+		slot.snapshot.status = "error";
+		slot.snapshot.pending = false;
+		slot.snapshot.stale = slot.hasValue;
+		slot.snapshot.error = toError(error);
+		publish(slot);
+		return;
+	}
+	Promise.resolve(result).then((iterable) => consume(slot, generation, iterable)).catch((error) => {
+		if (!isCurrent(slot, generation)) return;
+		slot.current = null;
+		slot.snapshot.status = "error";
+		slot.snapshot.pending = false;
+		slot.snapshot.stale = slot.hasValue;
+		slot.snapshot.error = toError(error);
+		publish(slot);
+	});
+}
+function queueStart(slot) {
+	if (slot.startQueued || slot.disposed || slot.explicitlyClosed) return;
+	slot.startQueued = true;
+	enqueueRuntimeLane("post", () => {
+		slot.startQueued = false;
+		if (!slot.owner?.notifyUpdate || slot.explicitlyClosed) return;
+		startSlot(slot);
+	});
+}
+function closeSlot(slot) {
+	if (slot.disposed) return;
+	slot.explicitlyClosed = true;
+	stopGeneration(slot.current);
+	slot.current = null;
+	slot.snapshot.status = "closed";
+	slot.snapshot.pending = false;
+	slot.snapshot.stale = slot.hasValue;
+	slot.snapshot.error = null;
+	publish(slot);
+}
+function createSnapshot(options) {
+	const hasInitialValue = Object.prototype.hasOwnProperty.call(options, "initialValue");
+	return {
+		value: hasInitialValue ? options.initialValue : null,
+		status: "connecting",
+		pending: !hasInitialValue,
+		stale: hasInitialValue,
+		error: null,
+		restart: () => {},
+		close: () => {}
+	};
+}
+function createSlot(source, options) {
+	const snapshot = createSnapshot(options);
+	const slot = {
+		kind: "stream",
+		source,
+		pendingSource: source,
+		deps: (options.deps ?? []).slice(),
+		pendingDeps: (options.deps ?? []).slice(),
+		snapshot,
+		generation: 0,
+		current: null,
+		activated: false,
+		disposed: false,
+		explicitlyClosed: false,
+		hasValue: Object.prototype.hasOwnProperty.call(options, "initialValue"),
+		cleanupRegistered: false,
+		startQueued: false,
+		owner: null
+	};
+	snapshot.restart = () => {
+		if (slot.disposed) return;
+		slot.explicitlyClosed = false;
+		if (slot.activated) {
+			if (!slot.startQueued) startSlot(slot);
+		}
+	};
+	snapshot.close = () => closeSlot(slot);
+	return slot;
+}
+function disposeSlot(slot) {
+	if (slot.disposed) return;
+	slot.disposed = true;
+	stopGeneration(slot.current);
+	slot.current = null;
+	slot.owner = null;
+	if (slot.activated && false);
+	slot.activated = false;
+}
+function commitSlot(instance, slot) {
+	const depsChanged = !depsEqual(slot.deps, slot.pendingDeps);
+	const firstCommit = !slot.activated;
+	const wasRunning = slot.current !== null;
+	slot.owner = instance;
+	slot.source = slot.pendingSource;
+	slot.deps = slot.pendingDeps;
+	if (firstCommit) slot.activated = true;
+	if (!slot.cleanupRegistered) {
+		slot.cleanupRegistered = true;
+		(instance.cleanupFns ??= []).push(() => disposeSlot(slot));
+	}
+	if (!slot.explicitlyClosed && (firstCommit || depsChanged && wasRunning)) queueStart(slot);
+}
+function getStreamSlot(instance, index, source, options) {
+	const slots = instance.lifecycleSlots ??= [];
+	const existing = slots[index];
+	if (existing) {
+		if (existing.kind !== "stream") throw new Error(`stream() lifecycle order violation: slot ${index} already belongs to ${existing.kind ?? "another primitive"}(). Keep lifecycle primitives in a stable top-level order.`);
+		return existing;
+	}
+	const slot = createSlot(source, options);
+	slots[index] = slot;
+	return slot;
+}
+function stream(source, options = {}) {
+	const instance = getCurrentComponentInstance();
+	if (!instance) return createSnapshot(options);
+	const slot = getStreamSlot(instance, claimHookIndex(instance, "stream"), source, options);
+	slot.pendingSource = source;
+	slot.pendingDeps = (options.deps ?? []).slice();
+	if (!instance.ssr) registerCommitOperation(() => commitSlot(instance, slot));
+	return slot.snapshot;
+}
+//#endregion
+export { capture, documentVisible, getSignal, on, onRouteChange, resource, routeActive, stream, task, timer, windowFocused };

package/dist/{route-matching-DLBWDeXX.js → route-matching-M-f1VQRu.js}

@@ -1,4 +1,278 @@
-import { n as getActiveRenderContext } from "./render-context-Clw3rFiO.js";
+import { t as enqueueRuntimeLane, v as logger } from "./access-ePqdQqkV.js";
+import { c as registerCommitOperationForInstance, d as getCurrentContextFrame, g as withAsyncResourceContext } from "./component-internal-CPjM4n8M.js";
+import { f as getCurrentComponentInstance } from "./component-scope-CC3cojX9.js";
+import { p as isPromiseLike } from "./lifecycle-batch-COgl8jMS.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-CVuQVjvK.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
 //#region src/router/match.ts
 function splitPathSegments(path) {
 	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
@@ -510,4 +784,4 @@ function _resolveRouteMatchFromRoutes(pathname, routeList) {
 	return findBestResolvedRouteFromRoutes(pathname, routeList);
 }
 //#endregion
-export { insertRecordSorted as A, getCurrentPathPrefix as C, getRouteRecords as D, getRouteList as E, snapshotRouteState as F, computeRank as I, normalizeRouteSegmentName as L, pushRegistrationScope as M, restoreRouteState as N, hasActivePageScope as O, setDefaultRouteAuthOptions as P, parseSegments as R, getCurrentPageScope as S, getDefaultRouteAuthOptions as T, getCurrentInheritedAuthRequirements as _, resolveRouteFromRoutes as a, getCurrentLayoutChain as b, deepFreeze as c, _setActiveRouteAuthOptions as d, addRouteToStores as f, getActiveRoutes as g, getActiveRouteAuthOptions as h, getMatchingRouteRecord as i, lockRouteRegistration as j, hasRegisteredRoutes as k, makeQuery as l, clearRouteState as m, computeMatchesFromRoutes as n, buildRouteContext as o, assertRouteRegistrationUnlocked as p, computeRouteActivityMatches as r, buildRouteContextBase as s, _resolveRouteMatchFromRoutes as t, parseLocation as u, getCurrentInheritedMeta as v, getCurrentScopeKind as w, getCurrentPageChain as x, getCurrentInheritedPolicies as y };
+export { insertRecordSorted as A, getCurrentPathPrefix as C, getRouteRecords as D, getRouteList as E, snapshotRouteState as F, computeRank as I, normalizeRouteSegmentName as L, pushRegistrationScope as M, restoreRouteState as N, hasActivePageScope as O, setDefaultRouteAuthOptions as P, parseSegments as R, getCurrentPageScope as S, getDefaultRouteAuthOptions as T, getCurrentInheritedAuthRequirements as _, resolveRouteFromRoutes as a, getCurrentLayoutChain as b, deepFreeze as c, _setActiveRouteAuthOptions as d, addRouteToStores as f, getActiveRoutes as g, getActiveRouteAuthOptions as h, getMatchingRouteRecord as i, lockRouteRegistration as j, hasRegisteredRoutes as k, makeQuery as l, clearRouteState as m, computeMatchesFromRoutes as n, buildRouteContext as o, assertRouteRegistrationUnlocked as p, computeRouteActivityMatches as r, buildRouteContextBase as s, _resolveRouteMatchFromRoutes as t, parseLocation as u, getCurrentInheritedMeta as v, getCurrentScopeKind as w, getCurrentPageChain as x, getCurrentInheritedPolicies as y, resource as z };

package/dist/router/index.d.ts

@@ -1,8 +1,9 @@
 import { c as RenderableChild } from "../control-DO-iBEtV.js";
 import { r as JSXElement, s as Props } from "../jsx-Dvr2SGRG.js";
 import "../types-DEhT-Nrv.js";
-import { A as RouteRecord, B as RouteSnapshot, C as RouteMetaSource, D as RoutePathParams, E as RouteParams, F as RouteRenderResult, I as RouteRequestOptions, L as RouteRequestResult, M as RouteRefSearch, N as RouteRegistry, O as RoutePolicy, P as RouteRegistryOptions, R as RouteSearch, S as RouteMeta, T as RouteOptions, _ as RouteDefinition, a as AccessRedirectDecision, b as RouteManifest, c as LayoutScopeRecord, d as ParsedSegment, f as Route, g as RouteContext, h as RouteComponent, i as AccessDenyStatus, j as RouteRef, k as RouteQuery, l as PageHelperOptions, m as RouteAuthResolver, n as AccessDecision, o as AccessRedirectStatus, p as RouteAuthOptions, r as AccessDenyDecision, s as GroupHelperOptions, t as AccessAllowDecision, u as PageScopeRecord, v as RouteDestination, w as RouteMode, x as RouteMatch, y as RouteHandler, z as RouteSearchValue } from "../router-C0XQA62W.js";
-import { a as ScrollRestorationOptions, i as NavigationScrollBehavior, n as NavigateOptions, r as HistoryScrollBehavior, t as navigate } from "../navigate-CV-RDqYP.js";
+import { A as RouteRecord, B as RouteSnapshot, C as RouteMetaSource, D as RoutePathParams, E as RouteParams, F as RouteRenderResult, I as RouteRequestOptions, L as RouteRequestResult, M as RouteRefSearch, N as RouteRegistry, O as RoutePolicy, P as RouteRegistryOptions, R as RouteSearch, S as RouteMeta, T as RouteOptions, _ as RouteDefinition, a as AccessRedirectDecision, b as RouteManifest, c as LayoutScopeRecord, d as ParsedSegment, f as Route, g as RouteContext, h as RouteComponent, i as AccessDenyStatus, j as RouteRef, k as RouteQuery, l as PageHelperOptions, m as RouteAuthResolver, n as AccessDecision, o as AccessRedirectStatus, p as RouteAuthOptions, r as AccessDenyDecision, s as GroupHelperOptions, t as AccessAllowDecision, u as PageScopeRecord, v as RouteDestination, w as RouteMode, x as RouteMatch, y as RouteHandler, z as RouteSearchValue } from "../router-C3vENhUh.js";
+import { a as ScrollRestorationOptions, i as NavigationScrollBehavior, n as NavigateOptions, r as HistoryScrollBehavior, t as navigate } from "../navigate-Cbq6QHVl.js";
+import { i as onRouteChange, n as RouteChangeOptions, r as currentRoute, t as RouteChangeCleanup } from "../activity-DZ-NCYr8.js";
 import { AuthContext, AuthContext as AuthContext$1, AuthRequirement, AuthRequirement as AuthRequirement$1 } from "@askrjs/auth";
 import { ObjectSchema } from "@askrjs/schema";
 //#region src/router/route-query.d.ts
@@ -39,9 +40,6 @@ declare function fallback(Component: RouteComponent): void;
 declare function route<const TPath extends string, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options?: RouteOptions<RoutePathParams<TPath>, TSearchSchema>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
 declare function route<const TPath extends string, TComponent extends AnyRouteComponent, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options?: RouteOptionsForComponent<TPath, TComponent, TSearchSchema>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
 //#endregion
-//#region src/router/activity.d.ts
-declare function currentRoute<TParams extends RouteParams = RouteParams>(): RouteSnapshot<TParams>;
-//#endregion
 //#region src/router/auth.d.ts
 /** Return the identity resolved for the route currently being rendered. */
 declare function currentAuth(): AuthContext$1;
@@ -128,6 +126,8 @@ type LinkBaseProps = Omit<Props, 'children' | 'href' | 'class' | 'rel' | 'target
    * Optional aria-label for accessibility when link text isn't descriptive enough.
    */
   'aria-label'?: string;
+  onPress?: (event: Event) => void;
+  onClick?: (event: MouseEvent) => void;
 };
 type LinkProps = LinkBaseProps & ({
   href: string;
@@ -163,6 +163,6 @@ type LinkProps = LinkBaseProps & ({
  * - Keyboard handling automatic
  * - Composable via mergeProps
  */
-declare function Link({ href: suppliedHref, to, class: className, children, rel, target, 'aria-current': ariaCurrent, 'aria-label': ariaLabel, ...rest }: LinkProps): JSXElement;
+declare function Link({ href: suppliedHref, to, class: className, children, rel, target, 'aria-current': ariaCurrent, 'aria-label': ariaLabel, onPress, onClick, ...rest }: LinkProps): JSXElement;
 //#endregion
-export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type AuthContext, type AuthRequirement, type Deferred, type DeferredState, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, type LazyRouteComponent, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, Resolve, type ResolveProps, type Route, type RouteAuthOptions, type RouteAuthResolver, type RouteComponent, type RouteContext, type RouteDefinition, type RouteDestination, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMeta, type RouteMetaSource, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRef, type RouteRegistry, type RouteRegistryOptions, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSearch, type RouteSearchValue, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, navigate, notFound, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to$1 as to, unauthorized, updateRouteQuery };
+export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type AuthContext, type AuthRequirement, type Deferred, type DeferredState, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, type LazyRouteComponent, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, Resolve, type ResolveProps, type Route, type RouteAuthOptions, type RouteAuthResolver, type RouteChangeCleanup, type RouteChangeOptions, type RouteComponent, type RouteContext, type RouteDefinition, type RouteDestination, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMeta, type RouteMetaSource, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRef, type RouteRegistry, type RouteRegistryOptions, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSearch, type RouteSearchValue, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, navigate, notFound, onRouteChange, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to$1 as to, unauthorized, updateRouteQuery };