@askrjs/askr 0.0.51 → 0.0.53

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

@@ -1,7 +1,7 @@
-import { enqueueRuntimeTask } from "./access.js";
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "./readable.js";
-import { getCurrentComponentInstance, getCurrentPortalScope } from "./component-scope.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-CO4hXlP4.js";
 //#region src/runtime/portal.ts
 function createPortalSlot() {
 	let currentValue;
@@ -50,6 +50,8 @@ function definePortal() {
 let _defaultPortalStates = /* @__PURE__ */ new Map();
 let _hasPendingDefaultPortalValue = false;
 let _pendingDefaultPortalValue = void 0;
+let _pendingDefaultPortalWrites = /* @__PURE__ */ new WeakMap();
+const _batchPortalWrites = /* @__PURE__ */ new WeakMap();
 function createExplicitHostSource(readCount) {
 	let source = (() => {
 		recordReadableRead(source);
@@ -69,19 +71,15 @@ function createDefaultPortalState() {
 	const state = {
 		portal: definePortal(),
 		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);
@@ -89,7 +87,36 @@ 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?.instance;
+	const target = host?.target;
+	const parent = target?.parentNode;
+	if (!host || !target || !parent) return;
+	const portalHost = target;
+	const hostedInstances = new Set(portalHost.__ASKR_INSTANCES ?? []);
+	if (portalHost.__ASKR_INSTANCE) hostedInstances.add(portalHost.__ASKR_INSTANCE);
+	for (const instance of hostedInstances) if (instance !== host) cleanupComponent(instance);
+	try {
+		delete portalHost.__ASKR_INSTANCE;
+		delete portalHost.__ASKR_INSTANCES;
+		delete portalHost.__ASKR_WRAPPER_HOST;
+	} catch {}
+	getRuntimeRenderer().teardownNodeSubtree(target);
+	const placeholder = document.createComment("");
+	placeholder.__ASKR_INSTANCE = host;
+	parent.replaceChild(placeholder, target);
+	host.target = null;
+	host._placeholder = placeholder;
+}
+function applyDefaultPortalWrite(state, children, owner) {
+	state.portal.render({ children });
+	state.owner = owner;
+	if (isEmptyPortalValue(children)) detachDefaultPortalHostOutput(state);
 }
 function isStaleDefaultPortalScope(scope) {
 	if (!isComponentPortalScope(scope)) return false;
@@ -125,10 +152,74 @@ 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);
+		if (!writes) {
+			writes = /* @__PURE__ */ new Map();
+			_batchPortalWrites.set(batch, writes);
+		}
+		const existing = writes.get(state);
+		if (existing) {
+			existing.owner = capturedOwner;
+			existing.children = props.children;
+			return;
+		}
+		const transaction = {
+			state,
+			owner: capturedOwner,
+			children: props.children,
+			batch
+		};
+		if (registerLifecycleTransaction(state, () => {
+			if (_batchPortalWrites.get(batch)?.get(state) !== transaction) return;
+			_batchPortalWrites.get(batch)?.delete(state);
+			applyDefaultPortalWrite(state, transaction.children, transaction.owner);
+		}, () => {
+			if (_batchPortalWrites.get(batch)?.get(state) === transaction) _batchPortalWrites.get(batch)?.delete(state);
+		}, () => {
+			const parentBatch = batch.parent;
+			const parentWrite = parentBatch ? _batchPortalWrites.get(parentBatch)?.get(state) : void 0;
+			if (parentWrite) {
+				parentWrite.owner = transaction.owner;
+				parentWrite.children = transaction.children;
+			}
+			_batchPortalWrites.get(batch)?.delete(state);
+		})) {
+			writes.set(state, transaction);
+			return;
+		}
+	}
+	const pending = _pendingDefaultPortalWrites.get(state);
+	if (pending) {
+		pending.owner = capturedOwner;
+		pending.children = props.children;
+		return;
+	}
+	const transaction = {
+		state,
+		owner: capturedOwner,
+		children: props.children
+	};
+	if (registerLifecycleTransaction(transaction, () => {
+		if (_pendingDefaultPortalWrites.get(state) !== transaction) return;
+		_pendingDefaultPortalWrites.delete(state);
+		_hasPendingDefaultPortalValue = false;
+		_pendingDefaultPortalValue = void 0;
+		applyDefaultPortalWrite(state, transaction.children, transaction.owner);
+	}, () => {
+		if (_pendingDefaultPortalWrites.get(state) === transaction) _pendingDefaultPortalWrites.delete(state);
+	})) {
+		_pendingDefaultPortalWrites.set(state, transaction);
+		return;
+	}
 	_hasPendingDefaultPortalValue = false;
 	_pendingDefaultPortalValue = void 0;
-	state.portal.render(props);
-	state.owner = owner;
+	applyDefaultPortalWrite(state, props.children, capturedOwner);
 }
 function applyPendingDefaultPortalValue(scope) {
 	if (!_hasPendingDefaultPortalValue) return;
@@ -142,34 +233,29 @@ function registerDefaultPortalOwner(owner) {
 	const scope = resolveDefaultPortalScope(owner);
 	if (!scope) return;
 	const state = getDefaultPortalState(scope);
-	if (state.cleanupOwners.has(owner)) return;
-	state.cleanupOwners.add(owner);
-	owner.cleanupFns.push(() => {
+	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) {
-			currentState.portal.render({ children: void 0 });
-			currentState.owner = null;
-		}
-		currentState.cleanupOwners.delete(owner);
+		if (currentState.owner?.instance === owner && currentState.owner.generation === 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);
-		owner.cleanupFns.push(() => {
+	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);
 		});
 	}
 }
@@ -182,6 +268,7 @@ function clearDefaultPortalForInstance(instance) {
 	_pendingDefaultPortalValue = void 0;
 	state.portal.render({ children: void 0 });
 	state.owner = null;
+	detachDefaultPortalHostOutput(state);
 }
 const DefaultPortal = (() => {
 	function Host(props) {
@@ -189,6 +276,10 @@ const DefaultPortal = (() => {
 		const scope = resolveDefaultPortalScope(owner);
 		if (!scope) return null;
 		const state = getDefaultPortalState(scope);
+		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);
@@ -208,6 +299,4 @@ function Portal(props) {
 	return null;
 }
 //#endregion
-export { DefaultPortal, Portal, clearDefaultPortalForInstance, definePortal, disposeDefaultPortalScope };
-
-//# sourceMappingURL=portal.js.map
+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,6 +58,4 @@ function throwSSRDataMissing() {
 	throw new SSRDataMissingError();
 }
 //#endregion
-export { configureRenderContextProvider, getActiveRenderContext, getCurrentRenderData, getNextRenderKey, resetRenderKeyCounter, startHydrationRenderPhase, startRenderPhase, stopHydrationRenderPhase, stopRenderPhase, throwSSRDataMissing };
-
-//# sourceMappingURL=render-context.js.map
+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 };