@askrjs/askr 0.0.51 → 0.0.52

package/dist/renderer/component-host-instances.js

@@ -1,3 +1,4 @@
+import { isProductionEnvironment } from "../common/env.js";
 import { getDevValue, incDevCounter } from "../runtime/dev-namespace.js";
 import { getCurrentInstance } from "../runtime/component-scope.js";
 import "../runtime/index.js";
@@ -19,6 +20,7 @@ function getVNodeComponentInstance(node) {
 function setVNodeComponentInstance(node, instance) {
 	if (typeof node !== "object" || node === null) return;
 	const objectNode = node;
+	vnodeComponentInstances.delete(objectNode);
 	if (Object.prototype.hasOwnProperty.call(objectNode, "__instance")) try {
 		objectNode.__instance = instance;
 		return;
@@ -29,8 +31,30 @@ function setVNodeComponentInstance(node, instance) {
 	} catch {}
 	vnodeComponentInstances.set(objectNode, instance);
 }
+/** @internal Restore component ownership after provisional creation fails. */
+function restoreVNodeComponentInstance(node, instance) {
+	if (typeof node !== "object" || node === null) return;
+	const objectNode = node;
+	vnodeComponentInstances.delete(objectNode);
+	if (instance) {
+		setVNodeComponentInstance(objectNode, instance);
+		return;
+	}
+	try {
+		delete objectNode.__instance;
+	} catch {
+		try {
+			objectNode.__instance = void 0;
+		} catch {}
+	}
+}
 let fallbackComponentInstanceId = 0;
+const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
 function nextComponentInstanceId() {
+	if (PRODUCTION_BUILD_ENABLED || isProductionEnvironment()) {
+		fallbackComponentInstanceId++;
+		return `comp-${fallbackComponentInstanceId}`;
+	}
 	const key = "__COMPONENT_INSTANCE_ID";
 	try {
 		incDevCounter(key);
@@ -48,18 +72,45 @@ function inheritComponentKey(target, source) {
 		if (!target.props) target.props = {};
 		const props = target.props;
 		if (props["data-key"] === void 0) props["data-key"] = String(inheritedKey);
+		if (props["data-askr-key-kind"] === void 0) props["data-askr-key-kind"] = typeof inheritedKey;
 	}
 	return target;
 }
-function findHostInstanceByType(host, type) {
+function setComponentOwnershipIdentity(instance, node, parent, wrapperDepth = 0, position) {
+	instance._vnodeOwner = typeof node === "object" && node !== null ? node : void 0;
+	instance._vnodeParent = parent;
+	const key = extractKey(node);
+	if (key === void 0) delete instance._vnodeKey;
+	else instance._vnodeKey = key;
+	instance._vnodePosition = position;
+	instance._wrapperDepth = wrapperDepth;
+}
+function findHostInstanceByType(host, type, node, parent, wrapperDepth) {
 	const instances = host.__ASKR_INSTANCES;
-	if (instances && instances.length > 0) for (let index = instances.length - 1; index >= 0; index -= 1) {
-		const instance = instances[index];
-		if (instance.fn === type) return instance;
+	if (instances && instances.length > 0) {
+		const vnodeOwner = getVNodeComponentInstance(node);
+		if (vnodeOwner && vnodeOwner.fn === type && instances.includes(vnodeOwner)) return vnodeOwner;
+		const key = extractKey(node);
+		const identityMatches = instances.filter((instance) => {
+			if (instance.fn !== type) return false;
+			if (parent !== void 0 && instance._vnodeParent !== parent) return false;
+			if (key !== void 0 && instance._vnodeKey !== key) return false;
+			if (wrapperDepth !== void 0 && instance._wrapperDepth !== wrapperDepth) return false;
+			return true;
+		});
+		if (identityMatches.length === 1) return identityMatches[0];
+		if (identityMatches.length > 1 && key !== void 0) return identityMatches[identityMatches.length - 1];
+		const sameType = instances.filter((instance) => instance.fn === type);
+		if (sameType.length === 1) return sameType[0];
+		return null;
+	}
+	if (host.__ASKR_INSTANCE?.fn === type) {
+		const instance = host.__ASKR_INSTANCE;
+		const key = extractKey(node);
+		if ((parent === void 0 || instance._vnodeParent === parent) && (key === void 0 || instance._vnodeKey === key) && (wrapperDepth === void 0 || instance._wrapperDepth === wrapperDepth)) return instance;
+		if (node === void 0 && parent === void 0 && wrapperDepth === void 0) return instance;
 	}
-	return host.__ASKR_INSTANCE?.fn === type ? host.__ASKR_INSTANCE : null;
+	return null;
 }
 //#endregion
-export { findHostInstanceByType, getVNodeComponentInstance, inheritComponentCleanupStrict, inheritComponentKey, isRouteRootComponentVNode, nextComponentInstanceId, setVNodeComponentInstance };
-
-//# sourceMappingURL=component-host-instances.js.map
+export { findHostInstanceByType, getVNodeComponentInstance, inheritComponentCleanupStrict, inheritComponentKey, isRouteRootComponentVNode, nextComponentInstanceId, restoreVNodeComponentInstance, setComponentOwnershipIdentity, setVNodeComponentInstance };

package/dist/renderer/component-host-replacement.js

@@ -0,0 +1,105 @@
+import { cleanupComponent } from "../runtime/component-cleanup.js";
+import { registerLifecycleRollback, registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
+import "../runtime/index.js";
+import { elementRefs, removeElementRef, updateElementRef } from "./cleanup.js";
+import { cleanupDetachedComponentHost } from "./component-host-cleanup.js";
+import { restoreVNodeComponentInstance } from "./component-host-instances.js";
+//#region src/renderer/component-host-replacement.ts
+function cleanupProvisionalComponentInstance(instance) {
+	try {
+		cleanupComponent(instance);
+	} catch {}
+}
+function cleanupProvisionalComponentInstances(instances) {
+	for (let index = instances.length - 1; index >= 0; index -= 1) cleanupProvisionalComponentInstance(instances[index]);
+}
+function createRetainedHostInstanceSet(owner, additional) {
+	const retained = /* @__PURE__ */ new Set([owner]);
+	for (const instance of additional ?? []) retained.add(instance);
+	return retained;
+}
+function cleanupReplacementNode(node, retainedInstance) {
+	if (node instanceof Element) {
+		cleanupDetachedComponentHost(node, retainedInstance);
+		return;
+	}
+	try {
+		delete node.__ASKR_INSTANCE;
+	} catch {}
+}
+function beginComponentHostReplacement(existingHost, retainedInstance, previousTarget, retainedInstances = [retainedInstance], disposeOnRollback = false) {
+	const parent = existingHost.parentNode;
+	const previousRef = elementRefs.get(existingHost);
+	let previousRefDetached = false;
+	let nextDom = null;
+	let didReplace = false;
+	let replacementAttempted = false;
+	let finished = false;
+	const commit = () => {
+		if (finished) return;
+		finished = true;
+		if (replacementAttempted && didReplace) cleanupDetachedComponentHost(existingHost, retainedInstances);
+	};
+	const rollback = () => {
+		if (finished) return;
+		finished = true;
+		if (!replacementAttempted) return;
+		const rollbackErrors = [];
+		if (nextDom && nextDom !== existingHost) try {
+			cleanupReplacementNode(nextDom, retainedInstance);
+		} catch (error) {
+			rollbackErrors.push(error);
+		}
+		try {
+			if (disposeOnRollback) cleanupComponent(retainedInstance);
+			else retainedInstance.target = previousTarget;
+		} catch (error) {
+			rollbackErrors.push(error);
+		}
+		if (previousRefDetached && previousRef) try {
+			updateElementRef(existingHost, previousRef);
+		} catch (error) {
+			rollbackErrors.push(error);
+		}
+		if (rollbackErrors.length > 0) throw new AggregateError(rollbackErrors, "Component host replacement rollback failed");
+	};
+	const staged = registerLifecycleTransaction({}, commit, rollback);
+	const replace = (materialize, prepareNextDom) => {
+		replacementAttempted = true;
+		if (!staged && previousRef) {
+			removeElementRef(existingHost);
+			previousRefDetached = true;
+		}
+		try {
+			nextDom = materialize();
+			prepareNextDom(nextDom);
+			if (parent && nextDom !== existingHost) {
+				parent.replaceChild(nextDom, existingHost);
+				didReplace = true;
+			}
+		} catch (error) {
+			if (!staged) try {
+				rollback();
+			} catch {}
+			throw error;
+		}
+		if (!staged) commit();
+		return nextDom;
+	};
+	return { replace };
+}
+function registerVNodeComponentInstanceRollback(node, previousInstance, provisionalInstance) {
+	let restored = false;
+	const restoreOwnership = () => {
+		if (restored) return;
+		restored = true;
+		restoreVNodeComponentInstance(node, previousInstance);
+	};
+	(provisionalInstance.cleanupFns ??= []).push(restoreOwnership);
+	registerLifecycleRollback(() => {
+		restoreOwnership();
+		cleanupProvisionalComponentInstance(provisionalInstance);
+	});
+}
+//#endregion
+export { beginComponentHostReplacement, cleanupProvisionalComponentInstance, cleanupProvisionalComponentInstances, createRetainedHostInstanceSet, registerVNodeComponentInstanceRollback };

package/dist/renderer/component-host-results.js

@@ -0,0 +1,138 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { getVNodeContextFrame, markVNodeTreeWithContextFrame, withContext } from "../runtime/context.js";
+import { getCurrentInstance } from "../runtime/component-scope.js";
+import { cleanupComponent } from "../runtime/component-cleanup.js";
+import { isPromiseLike } from "../common/promise.js";
+import { captureInlineRenderSnapshot, createComponentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads } from "../runtime/component-internal.js";
+import "../runtime/index.js";
+import { getRendererDOMHost } from "./dom-host.js";
+import { findHostInstanceByType, getVNodeComponentInstance, inheritComponentCleanupStrict, isRouteRootComponentVNode, nextComponentInstanceId, restoreVNodeComponentInstance, setComponentOwnershipIdentity, setVNodeComponentInstance } from "./component-host-instances.js";
+import { cleanupProvisionalComponentInstance, cleanupProvisionalComponentInstances, registerVNodeComponentInstanceRollback } from "./component-host-replacement.js";
+//#region src/renderer/component-host-results.ts
+function materializeComponentResultNode(childInstance, result, parentNamespace) {
+	const dom = getRendererDOMHost().createComponentResultNode(childInstance.fn, result, parentNamespace);
+	if (dom instanceof Element) {
+		mountInstanceInline(childInstance, dom);
+		return dom;
+	}
+	if (!dom) {
+		const placeholder = document.createComment("");
+		try {
+			placeholder.__ASKR_INSTANCE = childInstance;
+		} catch {}
+		childInstance._placeholder = placeholder;
+		mountInstanceInline(childInstance, null);
+		return placeholder;
+	}
+	const host = document.createElement("div");
+	host.appendChild(dom);
+	host.__ASKR_WRAPPER_HOST = true;
+	mountInstanceInline(childInstance, host);
+	return host;
+}
+function resolveNestedComponentResult(result, snapshot, parentInstance) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+		const nestedInstance = createComponentInstance(nextComponentInstanceId(), currentResult.type, currentResult.props ?? {}, null);
+		nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
+		nestedInstance.parentInstance = parentInstance;
+		nestedInstance.portalScope = parentInstance?.portalScope ?? nestedInstance.portalScope;
+		inheritComponentCleanupStrict(nestedInstance);
+		if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+		let nextResult;
+		try {
+			nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+			if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+		} catch (error) {
+			cleanupProvisionalComponentInstance(nestedInstance);
+			throw error;
+		}
+		cleanupComponent(nestedInstance);
+		activeSnapshot = nestedSnapshot ?? null;
+		currentResult = nextResult;
+		depth += 1;
+	}
+	return currentResult;
+}
+function resolveHostNestedComponentResult(host, retainedInstance, result, snapshot, retainedInstances) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	const createdInstances = [];
+	const createdVNodeOwners = [];
+	try {
+		while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+			const nestedVNode = currentResult;
+			const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+			let nestedInstance = findHostInstanceByType(host, currentResult.type, nestedVNode, retainedInstance, depth);
+			const hadNestedInstance = !!nestedInstance;
+			if (!nestedInstance) {
+				nestedInstance = createComponentInstance(nextComponentInstanceId(), currentResult.type, nestedVNode.props ?? {}, null);
+				createdInstances.push(nestedInstance);
+				const previous = getVNodeComponentInstance(nestedVNode);
+				createdVNodeOwners.push({
+					node: nestedVNode,
+					previous
+				});
+				registerVNodeComponentInstanceRollback(nestedVNode, previous, nestedInstance);
+			}
+			setComponentOwnershipIdentity(nestedInstance, nestedVNode, retainedInstance, depth);
+			if (hadNestedInstance) captureInlineRenderSnapshot(nestedInstance);
+			setVNodeComponentInstance(currentResult, nestedInstance);
+			nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
+			nestedInstance.parentInstance = retainedInstance;
+			nestedInstance.portalScope = retainedInstance.portalScope ?? nestedInstance.portalScope;
+			inheritComponentCleanupStrict(nestedInstance);
+			nestedInstance.props = (nestedVNode.props ?? {}) || {};
+			if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+			const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+			if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+			retainedInstances.add(nestedInstance);
+			warnUnusedStateReads(nestedInstance);
+			activeSnapshot = nestedSnapshot ?? null;
+			currentResult = markVNodeTreeWithContextFrame(nextResult, activeSnapshot);
+			depth += 1;
+		}
+		for (const instance of createdInstances) mountInstanceInline(instance, host);
+	} catch (error) {
+		for (let index = createdVNodeOwners.length - 1; index >= 0; index -= 1) {
+			const owner = createdVNodeOwners[index];
+			restoreVNodeComponentInstance(owner.node, owner.previous);
+		}
+		cleanupProvisionalComponentInstances(createdInstances);
+		throw error;
+	}
+	return currentResult;
+}
+function resolveWrapperHostResult(host, result, snapshot, retainedInstances) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+		const nestedInstance = findHostInstanceByType(host, currentResult.type, currentResult, getCurrentInstance(), depth);
+		if (!nestedInstance) break;
+		captureInlineRenderSnapshot(nestedInstance);
+		setComponentOwnershipIdentity(nestedInstance, currentResult, getCurrentInstance(), depth);
+		nestedInstance.props = (currentResult.props ?? {}) || {};
+		nestedInstance.parentInstance = getCurrentInstance();
+		nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
+		nestedInstance.portalScope = getCurrentInstance()?.portalScope ?? nestedInstance.portalScope;
+		inheritComponentCleanupStrict(nestedInstance);
+		if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+		const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+		if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+		retainedInstances.add(nestedInstance);
+		warnUnusedStateReads(nestedInstance);
+		activeSnapshot = nestedSnapshot ?? null;
+		currentResult = nextResult;
+		depth += 1;
+	}
+	return markVNodeTreeWithContextFrame(currentResult, activeSnapshot);
+}
+//#endregion
+export { materializeComponentResultNode, resolveHostNestedComponentResult, resolveNestedComponentResult, resolveWrapperHostResult };