@askrjs/askr 0.0.69 → 0.0.71

package/dist/{renderer-CBBbYZUO.js → renderer-BJYY2Y8s.js}

@@ -9,9 +9,9 @@ import { t as cleanupComponent } from "./component-cleanup-1ZFoLLHt.js";
 import { c as getCurrentLifecycleCommitBatch, l as registerLifecycleRollback, p as isPromiseLike, r as discardLifecycleCommitBatch, s as flushLifecycleCommitBatch, t as beginLifecycleCommitBatch, u as registerLifecycleTransaction } from "./lifecycle-batch-COgl8jMS.js";
 import { _ as createChildScope, a as registerForStateTransaction, c as captureForFallbackTransactionSnapshot, d as clearCaseDomUpdateState, f as clearShowDomUpdateState, g as evaluateShowState, h as evaluateCaseState, i as evaluateForState, l as captureForItemTransactionSnapshot, n as clearForDomUpdateState, o as rollbackForStateTransaction, t as beginForStateTransaction, v as disposeChildScope, y as rerenderChildScope } from "./for-internal-BtK9Htl0.js";
 import { n as createOwnedFineGrainedEffect, r as markFineGrainedEffectsDirtySource, t as createFineGrainedEffect } from "./effect-CFUzIpqX.js";
-import { C as getDelegatedHandlersForElement, D as updateDelegatedListener, E as removeDelegatedListener, S as getDelegatedHandlerForElement, T as isEventDelegationEnabled, _ as teardownNodeSubtree, a as elementReactivePropsCleanup, b as addFreshDelegatedListener, c as forEachElementReactivePropCleanup, d as removeAllListeners, f as removeElementReactiveProps, g as setFreshElementReactivePropCleanup, h as setDirectElementReactivePropCleanup, i as elementListeners, l as getElementReactivePropCleanupSize, m as replaceElementRefBookkeeping, n as cleanupInstanceIfPresent, o as elementRefs, p as removeElementRef, r as cleanupInstancesUnder, s as forEachDescendantNode, t as REACTIVE_CHILDREN_KEY, u as getElementReactivePropsCleanupMap, v as updateElementRef, w as isDelegatedEvent, x as clearDelegatedHandlersForElement, y as addDelegatedListener } from "./cleanup-UyStxIHG.js";
-import { t as getPublicAttributeName } from "./attr-names-CjhzmHOn.js";
-import { i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-HGZ0vbqT.js";
+import { C as getDelegatedHandlersForElement, D as updateDelegatedListener, E as removeDelegatedListener, S as getDelegatedHandlerForElement, T as isEventDelegationEnabled, _ as teardownNodeSubtree, a as elementReactivePropsCleanup, b as addFreshDelegatedListener, c as forEachElementReactivePropCleanup, d as removeAllListeners, f as removeElementReactiveProps, g as setFreshElementReactivePropCleanup, h as setDirectElementReactivePropCleanup, i as elementListeners, l as getElementReactivePropCleanupSize, m as replaceElementRefBookkeeping, n as cleanupInstanceIfPresent, o as elementRefs, p as removeElementRef, r as cleanupInstancesUnder, s as forEachDescendantNode, t as REACTIVE_CHILDREN_KEY, u as getElementReactivePropsCleanupMap, v as updateElementRef, w as isDelegatedEvent, x as clearDelegatedHandlersForElement, y as addDelegatedListener } from "./cleanup-D8Ufd9Ix.js";
+import { n as getPublicAttributeName, t as sanitizeCssValue } from "./css-BuPaTOfe.js";
+import { a as isSafeHref, i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-CwSRP3Jl.js";
 //#region src/runtime/error-boundary.ts
 function createBoundaryReset(instance) {
 	return () => {
@@ -500,7 +500,8 @@ function normalizeStyleEntries(value) {
 	const entries = /* @__PURE__ */ new Map();
 	for (const [key, entryValue] of Object.entries(value)) {
 		if (entryValue === void 0 || entryValue === null || entryValue === false) continue;
-		entries.set(normalizeStylePropertyName(key), String(entryValue));
+		const safeValue = sanitizeCssValue(String(entryValue));
+		if (safeValue) entries.set(normalizeStylePropertyName(key), safeValue);
 	}
 	return entries;
 }
@@ -554,6 +555,7 @@ function applyStaticScalarPropsToElement(el, props, tagName) {
 		if (key === "class" || key === "className") writeElementClassName(el, String(value));
 		else if (key === "style") applyStylePropValue(el, value);
 		else if (key === "value" || key === "checked") applyFormControlProp(el, key, value, tagName);
+		else if (key.toLowerCase() === "href" && !isSafeHref(String(value))) removeRenderedAttribute(el, key);
 		else setRenderedAttribute(el, key, String(value));
 	}
 }
@@ -619,6 +621,7 @@ function applyScalarPropValue(el, key, value, tagName, previousValue, descriptor
 	if (key === "class" || key === "className") applyClassPropValue(el, value, previousValue, descriptor);
 	else if (key === "style") applyStylePropValue(el, value);
 	else if (key === "value" || key === "checked") applyFormControlProp(el, key, value, tagName);
+	else if (key.toLowerCase() === "href" && !isSafeHref(String(value))) removeRenderedAttribute(el, key);
 	else setRenderedAttribute(el, key, String(value));
 }
 function removeStaleAttributes(el, vnode, props) {
@@ -2549,10 +2552,7 @@ function updateElementChildren$1(el, children, forceUpdate = false) {
 			keyedElements.delete(el);
 			return;
 		}
-		if (normalizedChildren.some(isControlBoundaryVNode) && normalizedChildren.every((child) => {
-			if (!isControlBoundaryVNode(child)) return true;
-			return getControlBoundaryState(child)?.kind !== "for";
-		})) {
+		if (normalizedChildren.some(isControlBoundaryVNode)) {
 			updateMixedControlChildren(el, normalizedChildren, forceUpdate);
 			keyedElements.delete(el);
 			return;
@@ -2611,6 +2611,7 @@ function removeRangeAtCursor(parent, cursor) {
 	return next;
 }
 function updateMixedControlChildren(parent, children, forceUpdate) {
+	clearControlBoundaryCommitOwner(parent);
 	const parentNamespace = getParentNamespace(parent);
 	const domHost = getRendererDOMHost();
 	let cursor = parent.firstChild;
@@ -2618,10 +2619,14 @@ function updateMixedControlChildren(parent, children, forceUpdate) {
 		if (isControlBoundaryVNode(child)) {
 			const controlState = getControlBoundaryState(child);
 			if (!controlState) throw new Error("[updateElementChildren] Control boundary missing internal state");
-			registerControlBoundaryCommitOwner(parent, controlState);
 			const childVNodes = evaluateControlBoundaryState(controlState);
 			const cursorAfterBoundary = cursor ? isRangeStart(cursor) ? findRangeEnd(cursor)?.nextSibling ?? cursor.nextSibling : cursor.nextSibling : null;
 			const ranges = syncControlBoundaryInMixedParent(parent, controlState, childVNodes, cursor);
+			if (controlState.kind === "for") {
+				const last = ranges[ranges.length - 1];
+				cursor = last ? last.end.nextSibling : cursorAfterBoundary?.parentNode === parent ? cursorAfterBoundary : cursor?.parentNode === parent ? cursor : null;
+				continue;
+			}
 			for (const range of ranges) if (range.start.parentNode !== parent) moveRange(parent, range, cursor?.parentNode === parent ? cursor : null);
 			else if (cursor?.parentNode === parent) moveRange(parent, range, cursor);
 			const last = ranges[ranges.length - 1];
@@ -3738,6 +3743,11 @@ function updateElementChildren(element, vnodeChildren, cleanupRangeNode) {
 		updateForBoundaryChildren(element, vnodeChildren[0]);
 		return;
 	}
+	if (vnodeChildren.some((child) => _isDOMElement(child) && child.type === __CONTROL_BOUNDARY__)) {
+		updateMixedControlChildren(element, vnodeChildren, false);
+		keyedElements.delete(element);
+		return;
+	}
 	if (hasKeyedChildren(vnodeChildren)) reconcileKeyed(element, vnodeChildren, getOrBuildKeyMap(element));
 	else reconcileUnkeyed(element, vnodeChildren);
 }
@@ -4398,7 +4408,78 @@ function syncControlBoundaryScopeNode(parent, scope, vnode) {
 	return range?.single ? range.start : null;
 }
 function syncControlBoundaryInMixedParent(parent, controlState, childrenVNodes, before) {
-	if (controlState.kind === "for") throw new Error("[askr] For ranges require the keyed boundary commit path.");
+	if (controlState.kind === "for") {
+		const ownedNodes = /* @__PURE__ */ new Set();
+		const collectRangeNodes = (range) => {
+			if (range.start.parentNode !== parent) return;
+			ownedNodes.add(range.start);
+			if (!range.single) {
+				let current = range.start.nextSibling;
+				while (current) {
+					ownedNodes.add(current);
+					if (current === range.end) break;
+					current = current.nextSibling;
+				}
+			}
+		};
+		for (const item of controlState.orderedItems) if (item?.scope.range) collectRangeNodes(item.scope.range);
+		if (controlState.fallbackScope?.range) collectRangeNodes(controlState.fallbackScope.range);
+		for (const range of controlState.lastRemovedRanges) collectRangeNodes(range);
+		for (const node of controlState.lastRemovedNodes) if (node.parentNode === parent) ownedNodes.add(node);
+		let afterBoundary = before;
+		while (afterBoundary && ownedNodes.has(afterBoundary)) afterBoundary = afterBoundary.nextSibling;
+		const nextRanges = [];
+		let syncBefore = before;
+		if (controlState.orderedKeys.length === 0) {
+			const fallbackScope = controlState.fallbackScope;
+			const fallbackVNode = childrenVNodes[0];
+			if (fallbackScope && fallbackVNode !== void 0) {
+				if (fallbackScope.hydrationPending && !fallbackScope.range && syncBefore instanceof Element && !checkVNodeShapeChanged(syncBefore, fallbackVNode)) {
+					assignScopeRange(fallbackScope, {
+						start: syncBefore,
+						end: syncBefore,
+						single: true
+					});
+					fallbackScope.hydrationPending = false;
+				}
+				const range = syncControlBoundaryScopeDom(parent, fallbackScope, fallbackVNode, syncBefore, controlState.lastRemovedRanges.length === 0, false);
+				if (range) {
+					nextRanges.push(range);
+					syncBefore = range.end.nextSibling;
+				}
+			}
+		} else for (let index = 0; index < controlState.orderedItems.length; index += 1) {
+			const item = controlState.orderedItems[index];
+			const vnode = childrenVNodes[index];
+			if (!item || vnode === void 0) continue;
+			if (item.scope.hydrationPending && !item.scope.range && syncBefore instanceof Element && getMaterializedKey(syncBefore) === controlState.orderedKeys[index] && !checkVNodeShapeChanged(syncBefore, vnode)) {
+				assignScopeRange(item.scope, {
+					start: syncBefore,
+					end: syncBefore,
+					single: true
+				});
+				item.scope.hydrationPending = false;
+			}
+			const range = syncControlBoundaryScopeDom(parent, item.scope, vnode, syncBefore, controlState.lastRemovedRanges.length === 0, false);
+			if (range) {
+				nextRanges.push(range);
+				syncBefore = range.end.nextSibling;
+			}
+		}
+		const previousAfterBoundary = afterBoundary;
+		if (previousAfterBoundary && nextRanges.some((range) => rangeContains(range, previousAfterBoundary))) afterBoundary = nextRanges[nextRanges.length - 1]?.end.nextSibling ?? null;
+		const nextRangeSet = new Set(nextRanges);
+		for (const range of controlState.lastRemovedRanges) if (!nextRangeSet.has(range)) removeRange(range, teardownBoundaryRangeNode);
+		for (const node of controlState.lastRemovedNodes) if (node.parentNode === parent && !nextRanges.some((range) => rangeContains(range, node))) teardownBoundaryRangeNode(node);
+		let anchor = afterBoundary?.parentNode === parent ? afterBoundary : null;
+		for (let index = nextRanges.length - 1; index >= 0; index -= 1) {
+			const range = nextRanges[index];
+			insertRangeBefore(parent, range, anchor);
+			anchor = range.start;
+		}
+		clearBoundaryState(controlState);
+		return nextRanges;
+	}
 	const activeScope = controlState.activeScope;
 	const activeVNode = childrenVNodes[0];
 	const nextRange = activeScope && activeVNode !== void 0 ? syncControlBoundaryScopeDom(parent, activeScope, activeVNode, before, controlState.lastRemovedRanges.length === 0) : null;

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 };