@askrjs/askr 0.0.52 → 0.0.53

package/dist/renderer/reconcile-resolution.js

@@ -1,163 +0,0 @@
-import { __FOR_BOUNDARY__ } from "../common/vnode.js";
-import { evaluateCaseState, evaluateShowState } from "../runtime/control.js";
-import { clearForDomUpdateState, evaluateForState } from "../runtime/for-internal.js";
-import "../runtime/index.js";
-import { extractKey, getMaterializedKey } from "./utils.js";
-import { canReuseIntrinsicElementInNamespace, getParentNamespace } from "./namespaces.js";
-import { getRendererDOMHost } from "./dom-host.js";
-//#region src/renderer/reconcile-resolution.ts
-function createOldElResolver(parent, oldKeyMap, usedOldEls) {
-	return (k) => {
-		if (!oldKeyMap) return void 0;
-		const direct = oldKeyMap.get(k);
-		if (direct && !usedOldEls.has(direct)) {
-			usedOldEls.add(direct);
-			return direct;
-		}
-		return scanForElementByKey(parent, k, usedOldEls);
-	};
-}
-function scanForElementByKey(parent, k, usedOldEls) {
-	try {
-		for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
-			if (usedOldEls.has(ch)) continue;
-			if (getMaterializedKey(ch) === k) {
-				usedOldEls.add(ch);
-				return ch;
-			}
-		}
-	} catch {}
-}
-function reconcileSingleChild(child, index, parent, resolveOldElOnce, resolveUnkeyedOnce, usedOldEls, newKeyMap) {
-	const resolvedControlBoundary = prepareControlBoundaryResolution(child);
-	if (resolvedControlBoundary !== null) {
-		if (resolvedControlBoundary.remount) return getRendererDOMHost().createDOMNode(resolvedControlBoundary.vnode, getParentNamespace(parent));
-		return reconcileSingleChild(resolvedControlBoundary.vnode, index, parent, resolveOldElOnce, resolveUnkeyedOnce, usedOldEls, newKeyMap);
-	}
-	const key = extractKey(child);
-	if (key !== void 0) return reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap);
-	return reconcileUnkeyedChild(child, index, parent, resolveUnkeyedOnce, usedOldEls);
-}
-function reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap) {
-	const el = resolveOldElOnce(key);
-	const parentNamespace = getParentNamespace(parent);
-	const domHost = getRendererDOMHost();
-	if (el && el.parentElement === parent) {
-		const childObj = child;
-		if (childObj && typeof childObj === "object" && typeof childObj.type === "string") {
-			if (canReuseIntrinsicElementInNamespace(el, childObj.type, parentNamespace)) {
-				domHost.updateElementFromVnode(el, child);
-				newKeyMap.set(key, el);
-				return el;
-			}
-		}
-		if (isComponentVNode(child)) {
-			const synced = domHost.syncComponentElement(el, child, child.type, (child.props ?? {}) || {}, parentNamespace);
-			if (synced) {
-				if (synced instanceof Element) newKeyMap.set(key, synced);
-				return synced;
-			}
-		}
-	}
-	const dom = domHost.createDOMNode(child, parentNamespace);
-	if (dom) {
-		if (dom instanceof Element) newKeyMap.set(key, dom);
-		return dom;
-	}
-	return null;
-}
-function reconcileUnkeyedChild(child, index, parent, resolveUnkeyedOnce, usedOldEls) {
-	const parentNamespace = getParentNamespace(parent);
-	const domHost = getRendererDOMHost();
-	const existing = parent.childNodes[index];
-	if (typeof child === "string" || typeof child === "number") {
-		if (existing && existing.nodeType === 3) {
-			existing.data = String(child);
-			usedOldEls.add(existing);
-			return existing;
-		}
-		return domHost.createDOMNode(child, parentNamespace);
-	}
-	if (existing instanceof Element) {
-		const synced = trySyncComponentChild(existing, child, usedOldEls, parentNamespace);
-		if (synced) return synced;
-	}
-	if (existing instanceof Element && canReuseElement(existing, child, parentNamespace)) {
-		domHost.updateElementFromVnode(existing, child);
-		usedOldEls.add(existing);
-		return existing;
-	}
-	const avail = resolveUnkeyedOnce();
-	if (avail) {
-		const reuseResult = tryReuseElement(avail, child, usedOldEls, parentNamespace);
-		if (reuseResult) return reuseResult;
-	}
-	return domHost.createDOMNode(child, parentNamespace);
-}
-function isComponentVNode(child) {
-	return typeof child === "object" && child !== null && "type" in child && typeof child.type === "function";
-}
-function isControlBoundaryVNode(child) {
-	return typeof child === "object" && child !== null && "type" in child && child.type === __FOR_BOUNDARY__;
-}
-function prepareControlBoundaryResolution(child) {
-	if (!isControlBoundaryVNode(child)) return null;
-	const controlState = child._controlState ?? child._forState;
-	if (!controlState) return null;
-	if (controlState.kind === "for") {
-		const childrenVNodes = evaluateControlBoundaryChildren(controlState);
-		if (childrenVNodes.length !== 1) return null;
-		clearForDomUpdateState(controlState);
-		return {
-			remount: false,
-			vnode: childrenVNodes[0] ?? null
-		};
-	}
-	const previousActiveKey = controlState.activeKey;
-	const childrenVNodes = evaluateControlBoundaryChildren(controlState);
-	return {
-		remount: previousActiveKey !== null && controlState.activeKey !== previousActiveKey,
-		vnode: childrenVNodes[0] ?? null
-	};
-}
-function evaluateControlBoundaryChildren(controlState) {
-	if (controlState.kind === "for") return evaluateForState(controlState);
-	if (controlState.kind === "show") return evaluateShowState(controlState);
-	return evaluateCaseState(controlState);
-}
-function trySyncComponentChild(existing, child, usedOldEls, parentNamespace) {
-	if (!isComponentVNode(child)) return null;
-	const synced = getRendererDOMHost().syncComponentElement(existing, child, child.type, (child.props ?? {}) || {}, parentNamespace);
-	if (!synced) return null;
-	usedOldEls.add(existing);
-	usedOldEls.add(synced);
-	return synced;
-}
-function canReuseElement(existing, child, parentNamespace) {
-	if (!existing) return false;
-	if (typeof child !== "object" || child === null || !("type" in child)) return false;
-	const childObj = child;
-	const existingKey = existing.getAttribute("data-key");
-	return (existingKey === null || existingKey === void 0) && typeof childObj.type === "string" && canReuseIntrinsicElementInNamespace(existing, childObj.type, parentNamespace);
-}
-function collectUnkeyedElements(parent) {
-	const elements = [];
-	for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) if (ch.getAttribute("data-key") === null) elements.push(ch);
-	return elements;
-}
-function tryReuseElement(avail, child, usedOldEls, parentNamespace) {
-	if (typeof child === "string" || typeof child === "number") return null;
-	const synced = trySyncComponentChild(avail, child, usedOldEls, parentNamespace);
-	if (synced) return synced;
-	if (typeof child === "object" && child !== null && "type" in child) {
-		const childObj = child;
-		if (typeof childObj.type === "string" && canReuseIntrinsicElementInNamespace(avail, childObj.type, parentNamespace)) {
-			getRendererDOMHost().updateElementFromVnode(avail, child);
-			usedOldEls.add(avail);
-			return avail;
-		}
-	}
-	return null;
-}
-//#endregion
-export { collectUnkeyedElements, createOldElResolver, reconcileSingleChild };

package/dist/renderer/reconcile.js

@@ -1,37 +0,0 @@
-import { buildDOMKeyMap, extractKeyedVnodes } from "./keyed-children.js";
-import { keyedElements } from "./keyed.js";
-import { commitReconciliation } from "./reconcile-commit.js";
-import { tryFastPaths } from "./reconcile-fastpaths.js";
-import { collectUnkeyedElements, createOldElResolver, reconcileSingleChild } from "./reconcile-resolution.js";
-function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
-	const keyedVnodes = extractKeyedVnodes(newChildren);
-	const ensuredOldKeyMap = oldKeyMap || buildDOMKeyMap(parent);
-	const fastPathResult = tryFastPaths(parent, newChildren, keyedVnodes, ensuredOldKeyMap);
-	if (fastPathResult) return fastPathResult;
-	return performFullReconciliation(parent, newChildren, ensuredOldKeyMap);
-}
-function performFullReconciliation(parent, newChildren, oldKeyMap) {
-	const newKeyMap = /* @__PURE__ */ new Map();
-	const finalNodes = [];
-	const usedOldEls = /* @__PURE__ */ new WeakSet();
-	const resolveOldElOnce = createOldElResolver(parent, oldKeyMap, usedOldEls);
-	const unkeyedEls = collectUnkeyedElements(parent);
-	let unkeyedIndex = 0;
-	const resolveUnkeyedOnce = () => {
-		while (unkeyedIndex < unkeyedEls.length) {
-			const candidate = unkeyedEls[unkeyedIndex++];
-			if (!usedOldEls.has(candidate)) return candidate;
-		}
-	};
-	for (let i = 0; i < newChildren.length; i++) {
-		const child = newChildren[i];
-		const node = reconcileSingleChild(child, i, parent, resolveOldElOnce, resolveUnkeyedOnce, usedOldEls, newKeyMap);
-		if (node) finalNodes.push(node);
-	}
-	if (typeof document === "undefined") return newKeyMap;
-	commitReconciliation(parent, finalNodes);
-	keyedElements.delete(parent);
-	return newKeyMap;
-}
-//#endregion
-export { reconcileKeyedChildren };

package/dist/renderer/retained-element-rollback.js

@@ -1,288 +0,0 @@
-import { logger } from "../common/logger.js";
-import { getCurrentLifecycleCommitBatch, registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
-import { addDelegatedListener, getDelegatedHandlersForElement, removeDelegatedListener, updateDelegatedListener } from "../runtime/events.js";
-import "../runtime/index.js";
-import { elementListeners, elementReactivePropsCleanup, elementRefs, getElementReactivePropsCleanupMap } from "./cleanup.js";
-import { keyedElements } from "./keyed.js";
-//#region src/renderer/retained-element-rollback.ts
-function collectTextSnapshots(root) {
-	const snapshots = [];
-	for (let index = 0; index < root.childNodes.length; index += 1) {
-		const node = root.childNodes[index];
-		if (node.nodeType === 3) {
-			const text = node;
-			snapshots.push({
-				node: text,
-				data: text.data
-			});
-		}
-	}
-	return snapshots;
-}
-function getFormControlSnapshot(element) {
-	const control = element;
-	const snapshot = {};
-	if ("value" in control) snapshot.value = String(control.value ?? "");
-	if ("checked" in control) snapshot.checked = Boolean(control.checked);
-	return snapshot.value !== void 0 || snapshot.checked !== void 0 ? snapshot : null;
-}
-function cloneListenerEntry(entry) {
-	return {
-		handler: entry.handler,
-		original: entry.original,
-		eventName: entry.eventName,
-		options: entry.options,
-		isDelegated: entry.isDelegated,
-		updateHandler: entry.updateHandler
-	};
-}
-function cloneReactivePropEntry(entry) {
-	return {
-		cleanup: entry.cleanup,
-		fnRef: entry.fnRef,
-		groupedScalar: entry.groupedScalar,
-		restoreFn: entry.restoreFn,
-		updateFn: entry.updateFn
-	};
-}
-function snapshotRetainedElement(element, bindingsOnly = false) {
-	const listenerMap = elementListeners.get(element);
-	const delegatedHandlerMap = getDelegatedHandlersForElement(element);
-	const reactivePropMap = getElementReactivePropsCleanupMap(element);
-	const keyedMap = keyedElements.get(element);
-	return {
-		attributes: bindingsOnly ? [] : Array.from(element.attributes, (attribute) => [attribute.name, attribute.value]),
-		childNodes: bindingsOnly ? [] : Array.from(element.childNodes),
-		delegatedListeners: delegatedHandlerMap ? Array.from(delegatedHandlerMap, ([eventName, entry]) => ({
-			eventName,
-			handler: entry.handler,
-			original: entry.original,
-			options: entry.options
-		})) : [],
-		domCaptured: !bindingsOnly,
-		formControl: bindingsOnly ? null : getFormControlSnapshot(element),
-		keyedMap: keyedMap ? new Map(keyedMap) : void 0,
-		listeners: listenerMap ? Array.from(listenerMap, ([listenerKey, entry]) => ({
-			listenerKey,
-			entry: cloneListenerEntry(entry)
-		})) : [],
-		reactiveProps: reactivePropMap ? Array.from(reactivePropMap, ([propName, entry]) => ({
-			propName,
-			entry: cloneReactivePropEntry(entry)
-		})) : [],
-		ref: elementRefs.get(element),
-		textNodes: bindingsOnly ? [] : collectTextSnapshots(element)
-	};
-}
-function sameChildOrder(element, childNodes) {
-	if (element.childNodes.length !== childNodes.length) return false;
-	for (let index = 0; index < childNodes.length; index += 1) if (element.childNodes[index] !== childNodes[index]) return false;
-	return true;
-}
-function restoreAttributes(element, snapshot) {
-	const expectedNames = new Set(snapshot.attributes.map(([name]) => name));
-	for (const attribute of Array.from(element.attributes)) if (!expectedNames.has(attribute.name)) element.removeAttribute(attribute.name);
-	for (const [name, value] of snapshot.attributes) if (element.getAttribute(name) !== value) element.setAttribute(name, value);
-}
-function restoreFormControl(element, snapshot) {
-	if (!snapshot.formControl) return;
-	const { value, checked } = snapshot.formControl;
-	const control = element;
-	if (value !== void 0 && "value" in control) control.value = value;
-	if (checked !== void 0 && "checked" in control) control.checked = checked;
-}
-function applyRefValue(ref, value) {
-	if (!ref) return;
-	try {
-		if (typeof ref === "function") {
-			ref(value);
-			return;
-		}
-		if (Object.isExtensible(ref)) ref.current = value;
-	} catch {}
-}
-function restoreRef(element, snapshot) {
-	const currentRef = elementRefs.get(element);
-	if (currentRef !== snapshot.ref) applyRefValue(currentRef, null);
-	if (snapshot.ref) {
-		applyRefValue(snapshot.ref, element);
-		elementRefs.set(element, snapshot.ref);
-	} else elementRefs.delete(element);
-}
-function removeDirectListener(element, entry) {
-	if (entry.isDelegated) return;
-	if (entry.options !== void 0) element.removeEventListener(entry.eventName, entry.handler, entry.options);
-	else element.removeEventListener(entry.eventName, entry.handler);
-}
-function addDirectListener(element, entry) {
-	if (entry.isDelegated) return;
-	if (entry.options !== void 0) element.addEventListener(entry.eventName, entry.handler, entry.options);
-	else element.addEventListener(entry.eventName, entry.handler);
-}
-function restoreListeners(element, snapshot) {
-	const errors = [];
-	const expectedKeys = new Set(snapshot.listeners.map(({ listenerKey }) => listenerKey));
-	let currentMap = elementListeners.get(element);
-	if (currentMap) {
-		for (const [listenerKey, entry] of Array.from(currentMap)) if (!expectedKeys.has(listenerKey)) {
-			try {
-				removeDirectListener(element, entry);
-			} catch (error) {
-				errors.push(error);
-			}
-			currentMap.delete(listenerKey);
-		}
-	}
-	if (snapshot.listeners.length === 0) {
-		if (currentMap?.size === 0) elementListeners.delete(element);
-	} else {
-		if (!currentMap) {
-			currentMap = /* @__PURE__ */ new Map();
-			elementListeners.set(element, currentMap);
-		}
-		for (const { listenerKey, entry } of snapshot.listeners) {
-			const currentEntry = currentMap.get(listenerKey);
-			entry.updateHandler?.(entry.original);
-			if (currentEntry && currentEntry.handler !== entry.handler) try {
-				removeDirectListener(element, currentEntry);
-			} catch (error) {
-				errors.push(error);
-			}
-			if (!currentEntry || currentEntry.handler !== entry.handler) try {
-				addDirectListener(element, entry);
-			} catch (error) {
-				errors.push(error);
-			}
-			else currentEntry.updateHandler?.(entry.original);
-			currentMap.set(listenerKey, cloneListenerEntry(entry));
-		}
-	}
-	if (errors.length > 0) throw new AggregateError(errors, "Listener rollback failed");
-}
-function restoreDelegatedListeners(element, snapshot) {
-	const errors = [];
-	const expectedEventNames = new Set(snapshot.delegatedListeners.map(({ eventName }) => eventName));
-	const currentMap = getDelegatedHandlersForElement(element);
-	if (currentMap) {
-		for (const eventName of currentMap.keys()) if (!expectedEventNames.has(eventName)) try {
-			removeDelegatedListener(element, eventName);
-		} catch (error) {
-			errors.push(error);
-		}
-	}
-	for (const { eventName, handler, original, options } of snapshot.delegatedListeners) try {
-		if (!updateDelegatedListener(element, eventName, handler, original, options)) addDelegatedListener(element, eventName, handler, original, options);
-	} catch (error) {
-		errors.push(error);
-	}
-	if (errors.length > 0) throw new AggregateError(errors, "Delegated listener rollback failed");
-}
-function restoreReactiveProps(element, snapshot) {
-	const errors = [];
-	const expectedPropNames = new Set(snapshot.reactiveProps.map(({ propName }) => propName));
-	let currentMap = getElementReactivePropsCleanupMap(element);
-	if (currentMap) {
-		for (const [propName, entry] of Array.from(currentMap)) if (!expectedPropNames.has(propName)) {
-			try {
-				entry.cleanup();
-			} catch (error) {
-				errors.push(error);
-			}
-			currentMap.delete(propName);
-		}
-	}
-	if (snapshot.reactiveProps.length === 0) {
-		if (currentMap?.size === 0) elementReactivePropsCleanup.delete(element);
-	} else {
-		if (!currentMap) {
-			currentMap = /* @__PURE__ */ new Map();
-			elementReactivePropsCleanup.set(element, currentMap);
-		}
-		for (const { propName, entry } of snapshot.reactiveProps) {
-			const currentEntry = currentMap.get(propName);
-			if (currentEntry) {
-				currentEntry.updateFn?.(entry.fnRef);
-				currentEntry.fnRef = entry.fnRef;
-				currentMap.set(propName, currentEntry);
-				continue;
-			}
-			currentMap.set(propName, (() => {
-				try {
-					return entry.restoreFn?.(entry.fnRef) ?? cloneReactivePropEntry(entry);
-				} catch (error) {
-					errors.push(error);
-					return cloneReactivePropEntry(entry);
-				}
-			})());
-		}
-	}
-	if (errors.length > 0) throw new AggregateError(errors, "Reactive property rollback failed");
-}
-function restoreChildNodes(element, snapshot, cleanupRangeNode) {
-	const errors = [];
-	const expectedChildren = new Set(snapshot.childNodes);
-	for (const child of Array.from(element.childNodes)) if (!expectedChildren.has(child)) try {
-		cleanupRangeNode(child);
-	} catch (error) {
-		errors.push(error);
-	}
-	if (!sameChildOrder(element, snapshot.childNodes)) element.replaceChildren(...snapshot.childNodes);
-	if (errors.length > 0) throw new AggregateError(errors, "DOM range rollback cleanup failed");
-}
-function restoreTextNodes(snapshot) {
-	for (const { node, data } of snapshot.textNodes) if (node.data !== data) node.data = data;
-}
-function restoreKeyedMap(element, snapshot) {
-	if (snapshot.keyedMap) keyedElements.set(element, new Map(snapshot.keyedMap));
-	else keyedElements.delete(element);
-}
-function restoreRetainedElement(element, snapshot, cleanupRangeNode) {
-	const errors = [];
-	const phases = [
-		...snapshot.domCaptured ? [
-			() => restoreChildNodes(element, snapshot, cleanupRangeNode),
-			() => restoreTextNodes(snapshot),
-			() => restoreFormControl(element, snapshot),
-			() => restoreAttributes(element, snapshot)
-		] : [],
-		() => restoreReactiveProps(element, snapshot),
-		() => restoreRef(element, snapshot),
-		() => restoreListeners(element, snapshot),
-		() => restoreDelegatedListeners(element, snapshot),
-		...snapshot.domCaptured ? [() => restoreKeyedMap(element, snapshot)] : []
-	];
-	for (const phase of phases) try {
-		phase();
-	} catch (error) {
-		errors.push(error);
-	}
-	if (errors.length > 0) throw new AggregateError(errors, "Retained element rollback failed");
-}
-function runRetainedElementUpdate(element, cleanupRangeNode, update, onError, bindingsOnly = false) {
-	const batch = getCurrentLifecycleCommitBatch();
-	const existingSnapshot = batch?.retainedElementSnapshots.get(element);
-	const snapshot = existingSnapshot ?? snapshotRetainedElement(element, bindingsOnly);
-	let restored = false;
-	if (batch && !existingSnapshot) {
-		batch.retainedElementSnapshots.set(element, snapshot);
-		registerLifecycleTransaction(element, () => void 0, () => {
-			if (restored) return;
-			restored = true;
-			restoreRetainedElement(element, snapshot, cleanupRangeNode);
-		});
-	}
-	try {
-		update();
-	} catch (err) {
-		onError?.();
-		try {
-			restored = true;
-			restoreRetainedElement(element, snapshot, cleanupRangeNode);
-		} catch (rollbackError) {
-			logger.warn("[Askr] retained element rollback failed:", new AggregateError([err, rollbackError], "Render failed and retained rollback reported errors"));
-		}
-		throw err;
-	}
-}
-//#endregion
-export { restoreRetainedElement, runRetainedElementUpdate, snapshotRetainedElement };

package/dist/renderer/stable-patch.js

@@ -1,80 +0,0 @@
-import { _isDOMElement } from "../common/vnode.js";
-import "./types.js";
-import { getCurrentContextFrame, getVNodeContextFrame, withContext } from "../runtime/context.js";
-import { incDevCounter } from "../runtime/dev-namespace.js";
-import { getCurrentInstance } from "../runtime/component-scope.js";
-import { isPromiseLike } from "../common/promise.js";
-import { captureInlineRenderSnapshot, renderComponentInline, warnUnusedStateReads } from "../runtime/component-internal.js";
-import { recordBenchEvent } from "../runtime/for-bench.js";
-import "../runtime/index.js";
-import { tagNamesEqualIgnoreCase } from "./utils.js";
-import { getRendererDOMHost } from "./dom-host.js";
-import { findHostInstanceByType, inheritComponentCleanupStrict, inheritComponentKey, isRouteRootComponentVNode } from "./component-host-instances.js";
-import { resolveNestedComponentResult } from "./component-host-results.js";
-import "./component-host.js";
-//#region src/renderer/stable-patch.ts
-function normalizeStableIntrinsicChildren(children) {
-	if (children === null || children === void 0 || children === false) return [];
-	return Array.isArray(children) ? children : [children];
-}
-function getStableIntrinsicChildren(vnode) {
-	return normalizeStableIntrinsicChildren(vnode.props?.children ?? vnode.children);
-}
-function patchStableIntrinsicText(domNode, nextVNode) {
-	if (domNode.nodeType !== 3 || typeof nextVNode !== "string" && typeof nextVNode !== "number") return false;
-	const nextText = String(nextVNode);
-	const textNode = domNode;
-	if (textNode.data !== nextText) {
-		recordBenchEvent("domTextSet");
-		textNode.data = nextText;
-	}
-	return true;
-}
-function patchStableIntrinsicElement(dom, nextVNode) {
-	if (typeof nextVNode.type !== "string" || !tagNamesEqualIgnoreCase(dom.tagName, nextVNode.type)) return false;
-	getRendererDOMHost().updateElementFromVnode(dom, nextVNode, false);
-	const nextChildren = getStableIntrinsicChildren(nextVNode);
-	if (dom.childNodes.length !== nextChildren.length) return false;
-	for (let index = 0; index < nextChildren.length; index += 1) {
-		const nextChild = nextChildren[index];
-		const currentChildNode = dom.childNodes[index];
-		if (!currentChildNode) return false;
-		if (patchStableIntrinsicText(currentChildNode, nextChild)) continue;
-		if (currentChildNode instanceof Element && _isDOMElement(nextChild) && typeof nextChild.type === "string" && patchStableIntrinsicElement(currentChildNode, nextChild)) continue;
-		return false;
-	}
-	return true;
-}
-function resolveStableIntrinsicPatchVNode(dom, vnode) {
-	if (!_isDOMElement(vnode)) return null;
-	if (typeof vnode.type === "string") return tagNamesEqualIgnoreCase(dom.tagName, vnode.type) ? vnode : null;
-	if (typeof vnode.type !== "function") return null;
-	const host = dom;
-	const existingInstance = findHostInstanceByType(host, vnode.type, vnode, getCurrentInstance());
-	if (!existingInstance || existingInstance.fn !== vnode.type || host.__ASKR_WRAPPER_HOST) return null;
-	const snapshot = getVNodeContextFrame(vnode) || getCurrentContextFrame() || existingInstance.ownerFrame || null;
-	captureInlineRenderSnapshot(existingInstance);
-	existingInstance.props = (vnode.props ?? {}) || {};
-	existingInstance.isRoot = isRouteRootComponentVNode(vnode);
-	existingInstance.portalScope = getCurrentInstance()?.portalScope ?? existingInstance.portalScope;
-	inheritComponentCleanupStrict(existingInstance);
-	if (snapshot) existingInstance.ownerFrame = snapshot;
-	const result = withContext(snapshot, () => renderComponentInline(existingInstance));
-	if (isPromiseLike(result)) throw new Error("Async components are not supported. Components must return synchronously.");
-	const resolvedResult = resolveNestedComponentResult(result, snapshot ?? null, existingInstance);
-	if (_isDOMElement(resolvedResult) && typeof resolvedResult.type === "string" && tagNamesEqualIgnoreCase(dom.tagName, resolvedResult.type)) return inheritComponentKey(resolvedResult, vnode);
-	return null;
-}
-function tryPatchStableForDirtyItem(scope) {
-	incDevCounter("stableForPatchAttempt");
-	if (!(scope.dom instanceof Element) || scope.vnode === void 0) return false;
-	const nextIntrinsic = resolveStableIntrinsicPatchVNode(scope.dom, scope.vnode);
-	if (!nextIntrinsic) return false;
-	const didPatch = patchStableIntrinsicElement(scope.dom, nextIntrinsic);
-	const existingInstance = scope.dom.__ASKR_INSTANCE;
-	if (didPatch && existingInstance) warnUnusedStateReads(existingInstance);
-	if (didPatch) incDevCounter("stableForPatchHit");
-	return didPatch;
-}
-//#endregion
-export { tryPatchStableForDirtyItem };

package/dist/renderer/static-reuse.js

@@ -1,94 +0,0 @@
-import { _isDOMElement } from "../common/vnode.js";
-import "./types.js";
-import { Fragment } from "../common/jsx.js";
-import { tagNamesEqualIgnoreCase } from "./utils.js";
-import "../jsx-runtime.js";
-import { hasMatchingStaticProps } from "./attributes.js";
-//#region src/renderer/static-reuse.ts
-/**
-* Static subtree reuse checks for intrinsic DOM children.
-*/
-function isFragmentVNode(node) {
-	return _isDOMElement(node) && typeof node.type === "symbol" && (node.type === Fragment || String(node.type) === "Symbol(askr.fragment)");
-}
-function upperCommonTagName(tag) {
-	switch (tag) {
-		case "div": return "DIV";
-		case "span": return "SPAN";
-		case "p": return "P";
-		case "a": return "A";
-		case "button": return "BUTTON";
-		case "input": return "INPUT";
-		case "ul": return "UL";
-		case "ol": return "OL";
-		case "li": return "LI";
-		default: return null;
-	}
-}
-function tagsEqualIgnoreCase(elementTagName, vnodeType) {
-	const upperCommon = upperCommonTagName(vnodeType);
-	if (upperCommon !== null && elementTagName === upperCommon) return true;
-	return tagNamesEqualIgnoreCase(elementTagName, vnodeType);
-}
-const STATIC_CHILD_SLOTS_CACHE = Symbol.for("__askrStaticChildSlots");
-let staticChildSlotsCacheEnabled = true;
-function setStaticChildSlotsCacheEnabled(enabled) {
-	staticChildSlotsCacheEnabled = enabled;
-}
-function collectStaticChildSlots(children, slots) {
-	if (isFragmentVNode(children)) return collectStaticChildSlots(children.props?.children ?? children.children, slots);
-	if (Array.isArray(children)) {
-		for (const child of children) if (!collectStaticChildSlots(child, slots)) return false;
-		return true;
-	}
-	if (children === null || children === void 0 || children === false) return true;
-	if (typeof children === "string" || typeof children === "number") {
-		slots.push({
-			kind: "text",
-			value: String(children)
-		});
-		return true;
-	}
-	if (_isDOMElement(children) && typeof children.type === "string") {
-		slots.push({
-			kind: "element",
-			value: children
-		});
-		return true;
-	}
-	return false;
-}
-function getStaticChildSlots(vnode) {
-	if (staticChildSlotsCacheEnabled) {
-		const cached = vnode[STATIC_CHILD_SLOTS_CACHE];
-		if (cached !== void 0) return cached;
-	}
-	const slots = [];
-	const staticSlots = collectStaticChildSlots(vnode.props?.children ?? vnode.children, slots) ? slots : null;
-	if (staticChildSlotsCacheEnabled) {
-		const cacheNode = vnode;
-		if (Object.isExtensible(vnode)) cacheNode[STATIC_CHILD_SLOTS_CACHE] = staticSlots;
-	}
-	return staticSlots;
-}
-function canReuseStaticSubtree(el, vnode) {
-	if (typeof vnode.type !== "string" || !tagsEqualIgnoreCase(el.tagName, vnode.type)) return false;
-	if (!hasMatchingStaticProps(el, vnode.props || {}, vnode.type)) return false;
-	const slots = getStaticChildSlots(vnode);
-	if (!slots) return false;
-	if (el.childNodes.length !== slots.length) return false;
-	for (let index = 0; index < slots.length; index += 1) {
-		const slot = slots[index];
-		const current = el.childNodes[index];
-		if (!current) return false;
-		if (slot.kind === "text") {
-			if (current.nodeType !== 3 || current.data !== slot.value) return false;
-			continue;
-		}
-		if (!(current instanceof Element)) return false;
-		if (!canReuseStaticSubtree(current, slot.value)) return false;
-	}
-	return true;
-}
-//#endregion
-export { canReuseStaticSubtree, setStaticChildSlotsCacheEnabled, tagsEqualIgnoreCase };

package/dist/renderer/types.js

@@ -1,2 +0,0 @@
-import { _isDOMElement } from "../common/vnode.js";
-export { _isDOMElement };