@askrjs/askr 0.0.52 → 0.0.54

package/dist/{runtime/portal.js → portal-C47xkwXj.js}

@@ -1,10 +1,7 @@
-import { enqueueRuntimeTask, getRuntimeRenderer } from "./access.js";
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "./readable.js";
-import { getCurrentComponentInstance, getCurrentPortalScope } from "./component-scope.js";
-import { cleanupComponent } from "./component-cleanup.js";
-import { getCurrentLifecycleCommitBatch, registerLifecycleTransaction } from "./lifecycle-batch.js";
-import "./component-lifecycle.js";
-import "./component.js";
+import { o as getRuntimeRenderer } from "./access-Bg4RJNC8.js";
+import { f as notifyReadableReaders, l as markReactivePropsDirtySource, p as recordReadableRead, u as markReadableDerivedSubscribersDirty } from "./fastlane-Dw8SOBr9.js";
+import { f as getCurrentComponentInstance, m as getCurrentPortalScope } from "./component-scope-CC3cojX9.js";
+import { f as registerLifecycleTransaction, h as cleanupComponent, u as getCurrentLifecycleCommitBatch } from "./component-lifecycle-C7lnU9Bt.js";
 //#region src/runtime/portal.ts
 function createPortalSlot() {
 	let currentValue;
@@ -55,6 +52,26 @@ let _hasPendingDefaultPortalValue = false;
 let _pendingDefaultPortalValue = void 0;
 let _pendingDefaultPortalWrites = /* @__PURE__ */ new WeakMap();
 const _batchPortalWrites = /* @__PURE__ */ new WeakMap();
+function trackBatchPortalWrite(batch, state, transaction) {
+	let current = batch;
+	while (current) {
+		let writes = _batchPortalWrites.get(current);
+		if (!writes) {
+			writes = /* @__PURE__ */ new Map();
+			_batchPortalWrites.set(current, writes);
+		}
+		if (!writes.has(state)) writes.set(state, transaction);
+		current = current.parent;
+	}
+}
+function clearTrackedBatchPortalWrite(transaction) {
+	let batch = transaction.batch ?? null;
+	while (batch) {
+		const writes = _batchPortalWrites.get(batch);
+		if (writes?.get(transaction.state) === transaction) writes.delete(transaction.state);
+		batch = batch.parent;
+	}
+}
 function createExplicitHostSource(readCount) {
 	let source = (() => {
 		recordReadableRead(source);
@@ -76,18 +93,13 @@ function createDefaultPortalState() {
 		owner: null,
 		host: null,
 		cleanupOwners: /* @__PURE__ */ new WeakSet(),
-		explicitHostOwners: /* @__PURE__ */ new Set(),
+		explicitHostOwners: /* @__PURE__ */ new Map(),
 		explicitHostCleanupOwners: /* @__PURE__ */ new WeakSet(),
 		explicitHostSource: (() => 0)
 	};
 	state.explicitHostSource = createExplicitHostSource(() => state.explicitHostOwners.size);
 	return state;
 }
-function isExplicitHostOwnerConnected(owner) {
-	if (owner.target) return owner.target.isConnected;
-	if (owner._placeholder) return owner._placeholder.isConnected;
-	return owner.mounted;
-}
 function disposeDefaultPortalScope(scope) {
 	if (!scope) return;
 	const state = _defaultPortalStates.get(scope);
@@ -95,13 +107,13 @@ function disposeDefaultPortalScope(scope) {
 	_defaultPortalStates.delete(scope);
 }
 function isComponentPortalScope(scope) {
-	return Array.isArray(scope.cleanupFns);
+	return "lifecycleGeneration" in scope && "evaluationGeneration" in scope && "parentInstance" in scope;
 }
 function isEmptyPortalValue(value) {
 	return value === null || value === void 0 || value === false;
 }
 function detachDefaultPortalHostOutput(state) {
-	const host = state.host;
+	const host = state.host?.instance;
 	const target = host?.target;
 	const parent = target?.parentNode;
 	if (!host || !target || !parent) return;
@@ -160,6 +172,10 @@ function writeDefaultPortal(props, owner) {
 		return;
 	}
 	const state = getDefaultPortalState(scope);
+	const capturedOwner = owner ? {
+		instance: owner,
+		generation: owner._ownershipGeneration
+	} : null;
 	const batch = getCurrentLifecycleCommitBatch();
 	if (batch) {
 		let writes = _batchPortalWrites.get(batch);
@@ -169,44 +185,44 @@ function writeDefaultPortal(props, owner) {
 		}
 		const existing = writes.get(state);
 		if (existing) {
-			existing.owner = owner;
+			existing.owner = capturedOwner;
 			existing.children = props.children;
 			return;
 		}
 		const transaction = {
 			state,
-			owner,
+			owner: capturedOwner,
 			children: props.children,
 			batch
 		};
 		if (registerLifecycleTransaction(state, () => {
 			if (_batchPortalWrites.get(batch)?.get(state) !== transaction) return;
-			_batchPortalWrites.get(batch)?.delete(state);
+			clearTrackedBatchPortalWrite(transaction);
 			applyDefaultPortalWrite(state, transaction.children, transaction.owner);
 		}, () => {
-			if (_batchPortalWrites.get(batch)?.get(state) === transaction) _batchPortalWrites.get(batch)?.delete(state);
+			clearTrackedBatchPortalWrite(transaction);
 		}, () => {
 			const parentBatch = batch.parent;
 			const parentWrite = parentBatch ? _batchPortalWrites.get(parentBatch)?.get(state) : void 0;
-			if (parentWrite) {
+			if (parentWrite && parentWrite !== transaction) {
 				parentWrite.owner = transaction.owner;
 				parentWrite.children = transaction.children;
 			}
-			_batchPortalWrites.get(batch)?.delete(state);
+			clearTrackedBatchPortalWrite(transaction);
 		})) {
-			writes.set(state, transaction);
+			trackBatchPortalWrite(batch, state, transaction);
 			return;
 		}
 	}
 	const pending = _pendingDefaultPortalWrites.get(state);
 	if (pending) {
-		pending.owner = owner;
+		pending.owner = capturedOwner;
 		pending.children = props.children;
 		return;
 	}
 	const transaction = {
 		state,
-		owner,
+		owner: capturedOwner,
 		children: props.children
 	};
 	if (registerLifecycleTransaction(transaction, () => {
@@ -223,7 +239,7 @@ function writeDefaultPortal(props, owner) {
 	}
 	_hasPendingDefaultPortalValue = false;
 	_pendingDefaultPortalValue = void 0;
-	applyDefaultPortalWrite(state, props.children, owner);
+	applyDefaultPortalWrite(state, props.children, capturedOwner);
 }
 function applyPendingDefaultPortalValue(scope) {
 	if (!_hasPendingDefaultPortalValue) return;
@@ -233,35 +249,46 @@ function applyPendingDefaultPortalValue(scope) {
 	_hasPendingDefaultPortalValue = false;
 	_pendingDefaultPortalValue = void 0;
 }
+function getPendingDefaultPortalWrite(state) {
+	let batch = getCurrentLifecycleCommitBatch();
+	while (batch) {
+		const pending = _batchPortalWrites.get(batch)?.get(state);
+		if (pending) return pending;
+		batch = batch.parent;
+	}
+	return _pendingDefaultPortalWrites.get(state);
+}
+function hasPendingReplacementPortalOwner(state, owner, generation) {
+	const pendingOwner = getPendingDefaultPortalWrite(state)?.owner;
+	return Boolean(pendingOwner && (pendingOwner.instance !== owner || pendingOwner.generation !== generation));
+}
 function registerDefaultPortalOwner(owner) {
 	const scope = resolveDefaultPortalScope(owner);
 	if (!scope) return;
 	const state = getDefaultPortalState(scope);
-	if (state.cleanupOwners.has(owner)) return;
-	state.cleanupOwners.add(owner);
+	const generation = owner._ownershipGeneration;
+	if (state.cleanupOwners.has(generation)) return;
+	state.cleanupOwners.add(generation);
 	(owner.cleanupFns ??= []).push(() => {
 		const currentState = _defaultPortalStates.get(scope);
 		if (!currentState) return;
-		if (currentState.owner === owner) applyDefaultPortalWrite(currentState, void 0, null);
-		currentState.cleanupOwners.delete(owner);
+		if (currentState.owner?.instance === owner && currentState.owner.generation === generation && !hasPendingReplacementPortalOwner(currentState, owner, generation)) applyDefaultPortalWrite(currentState, void 0, null);
+		if (currentState.cleanupOwners.delete(generation)) {}
 	});
 }
 function registerExplicitDefaultPortalHost(scope, state, owner) {
 	if (!owner) return;
-	if (!state.explicitHostOwners.has(owner)) {
-		state.explicitHostOwners.add(owner);
+	const generation = owner._ownershipGeneration;
+	if (!state.explicitHostOwners.has(generation)) {
+		state.explicitHostOwners.set(generation, owner);
 		notifyExplicitDefaultPortalHostReaders(state);
 	}
-	if (!state.explicitHostCleanupOwners.has(owner)) {
-		state.explicitHostCleanupOwners.add(owner);
+	if (!state.explicitHostCleanupOwners.has(generation)) {
+		state.explicitHostCleanupOwners.add(generation);
 		(owner.cleanupFns ??= []).push(() => {
 			if (_defaultPortalStates.get(scope) !== state) return;
-			state.explicitHostCleanupOwners.delete(owner);
-			enqueueRuntimeTask(() => {
-				if (_defaultPortalStates.get(scope) !== state) return;
-				if (isExplicitHostOwnerConnected(owner)) return;
-				if (state.explicitHostOwners.delete(owner)) notifyExplicitDefaultPortalHostReaders(state);
-			});
+			state.explicitHostCleanupOwners.delete(generation);
+			if (state.explicitHostOwners.get(generation) === owner && state.explicitHostOwners.delete(generation)) notifyExplicitDefaultPortalHostReaders(state);
 		});
 	}
 }
@@ -282,7 +309,10 @@ const DefaultPortal = (() => {
 		const scope = resolveDefaultPortalScope(owner);
 		if (!scope) return null;
 		const state = getDefaultPortalState(scope);
-		state.host = owner;
+		state.host = owner ? {
+			instance: owner,
+			generation: owner._ownershipGeneration
+		} : null;
 		if (!(props?.__askrAutoDefaultPortal === true)) registerExplicitDefaultPortalHost(scope, state, owner);
 		else if (readExplicitDefaultPortalHosts(state) > 0) return null;
 		applyPendingDefaultPortalValue(scope);
@@ -302,4 +332,4 @@ function Portal(props) {
 	return null;
 }
 //#endregion
-export { DefaultPortal, Portal, clearDefaultPortalForInstance, definePortal, disposeDefaultPortalScope };
+export { disposeDefaultPortalScope as a, definePortal as i, Portal as n, clearDefaultPortalForInstance as r, DefaultPortal as t };

package/dist/query-registry-CQIT4mXr.js

@@ -0,0 +1,73 @@
+import { i as getDefaultDataRuntime, t as createDataRuntime } from "./data-runtime-SJ1BSUvk.js";
+//#region src/common/telemetry.ts
+function withTelemetry(span, fields, work) {
+	return span ? span(fields, work) : work();
+}
+//#endregion
+//#region src/data/query-registry.ts
+function serveQuery(query, handler) {
+	return Object.freeze({
+		query,
+		handler
+	});
+}
+function defineServerQueries(...entries) {
+	const frozenEntries = Object.freeze([...entries]);
+	const handlers = new Map(entries.map((entry) => [entry.query, entry.handler]));
+	return Object.freeze({
+		entries: frozenEntries,
+		get(query) {
+			return handlers.get(query);
+		}
+	});
+}
+function defineQuery(definition) {
+	return Object.freeze({ ...definition });
+}
+function createQueryPrefetchContext(options = {}) {
+	const runtime = options.runtime ?? (options.mode === "spa" ? getDefaultDataRuntime() : createDataRuntime());
+	const signal = options.signal ?? new AbortController().signal;
+	return {
+		runtime,
+		request: options.request,
+		signal,
+		mode: options.mode ?? "spa",
+		async prefetch(query, input) {
+			return withTelemetry(options.telemetry?.queryPrefetch, {}, async () => {
+				const key = query.key(input);
+				if (runtime.queryData.has(key)) return true;
+				let value;
+				const handler = options.mode === "ssr" ? options.registry?.get(query) : void 0;
+				if (options.mode === "ssr" && !handler) return false;
+				value = handler ? await handler({
+					input,
+					request: options.request,
+					signal
+				}) : await query.fetch({
+					...input,
+					signal
+				});
+				if (signal.aborted) return false;
+				runtime.queryData.set(key, value);
+				return true;
+			});
+		}
+	};
+}
+async function prefetchQuery(context, query, input) {
+	return context.prefetch(query, input);
+}
+function dehydrateDataRuntime(runtime) {
+	const result = {};
+	for (const [key, value] of runtime.queryData) try {
+		JSON.stringify(value);
+		result[key] = value;
+	} catch {}
+	return result;
+}
+function hydrateDataRuntime(runtime, data) {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return;
+	for (const [key, value] of Object.entries(data)) runtime.queryData.set(key, value);
+}
+//#endregion
+export { hydrateDataRuntime as a, withTelemetry as c, dehydrateDataRuntime as i, defineQuery as n, prefetchQuery as o, defineServerQueries as r, serveQuery as s, createQueryPrefetchContext as t };

package/dist/{common/render-context.js → render-context-Clw3rFiO.js}

@@ -1,4 +1,16 @@
-import { SSRDataMissingError } from "./ssr-errors.js";
+//#region src/common/ssr-errors.ts
+/**
+* Common call contracts: SSR error types
+*/
+var SSRDataMissingError = class SSRDataMissingError extends Error {
+	constructor(message = "Server-side rendering requires all data to be available synchronously. This component attempted to use async data during SSR.") {
+		super(message);
+		this.code = "SSR_DATA_MISSING";
+		this.name = "SSRDataMissingError";
+		Object.setPrototypeOf(this, SSRDataMissingError.prototype);
+	}
+};
+//#endregion
 //#region src/common/render-context.ts
 let provider = { getRenderContext() {
 	return null;
@@ -14,10 +26,6 @@ function getActiveRenderContext() {
 function getCurrentRenderData() {
 	return getActiveRenderContext()?.renderData ?? hydrationRenderData;
 }
-function resetRenderKeyCounter() {
-	const ctx = getActiveRenderContext();
-	if (ctx) ctx.keyCounter = 0;
-}
 function getNextRenderKey() {
 	const ctx = getActiveRenderContext();
 	if (ctx) return `r:${ctx.keyCounter++}`;
@@ -50,4 +58,4 @@ function throwSSRDataMissing() {
 	throw new SSRDataMissingError();
 }
 //#endregion
-export { configureRenderContextProvider, getActiveRenderContext, getCurrentRenderData, getNextRenderKey, resetRenderKeyCounter, startHydrationRenderPhase, startRenderPhase, stopHydrationRenderPhase, stopRenderPhase, throwSSRDataMissing };
+export { startHydrationRenderPhase as a, stopRenderPhase as c, getNextRenderKey as i, throwSSRDataMissing as l, getActiveRenderContext as n, startRenderPhase as o, getCurrentRenderData as r, stopHydrationRenderPhase as s, configureRenderContextProvider as t, SSRDataMissingError as u };