@askrjs/askr 0.0.52 → 0.0.54

package/dist/cleanup-DScKZG2i.js

@@ -0,0 +1,487 @@
+import { c as runRuntimeHandlerScope, v as logger } from "./access-Bg4RJNC8.js";
+import "./fastlane-Dw8SOBr9.js";
+import { f as registerLifecycleTransaction, h as cleanupComponent } from "./component-lifecycle-C7lnU9Bt.js";
+//#region src/runtime/events.ts
+/**
+* Event delegation system for Askr
+*
+* Provides efficient event handling by attaching listeners to a container
+* instead of individual elements. This significantly reduces memory usage
+* and improves performance when many elements have the same event type.
+*
+* Delegated handling is enabled by default. Tests and internal runtime code
+* can still disable or re-enable it when they need to exercise both modes.
+*/
+const DELEGATED_EVENTS = [
+	"click",
+	"dblclick",
+	"mousedown",
+	"mouseup",
+	"mouseover",
+	"mouseout",
+	"mousemove",
+	"focus",
+	"blur",
+	"input",
+	"change",
+	"keydown",
+	"keyup",
+	"keypress",
+	"submit",
+	"scroll",
+	"wheel",
+	"touchstart",
+	"touchend",
+	"touchmove",
+	"touchcancel"
+];
+const DELEGATED_HANDLERS = Symbol("askr.delegated-handlers");
+const delegatedHandlerFallback = /* @__PURE__ */ new WeakMap();
+function getDelegatedHandlerStore(element) {
+	return element[DELEGATED_HANDLERS] ?? delegatedHandlerFallback.get(element);
+}
+function setDelegatedHandlerStore(element, store) {
+	const host = element;
+	try {
+		host[DELEGATED_HANDLERS] = store;
+		if (host[DELEGATED_HANDLERS] === store) return;
+	} catch {}
+	delegatedHandlerFallback.set(element, store);
+}
+function deleteDelegatedHandlerStore(element) {
+	const host = element;
+	if (host[DELEGATED_HANDLERS] !== void 0) try {
+		delete host[DELEGATED_HANDLERS];
+		return;
+	} catch {}
+	delegatedHandlerFallback.delete(element);
+}
+let eventDelegationEnabled = true;
+const containerDelegatedListeners = /* @__PURE__ */ new Map();
+function isEventDelegationEnabled() {
+	return eventDelegationEnabled;
+}
+function decrementContainerListenerUsage(entry) {
+	const listeners = containerDelegatedListeners.get(entry.container);
+	const listener = listeners?.get(entry.eventName);
+	if (!listener) return;
+	listener.usage -= 1;
+	if (listener.usage > 0) return;
+	entry.container.removeEventListener(entry.eventName, listener.handler);
+	listeners?.delete(entry.eventName);
+	if (listeners?.size === 0) containerDelegatedListeners.delete(entry.container);
+}
+function getDelegationContainer() {
+	if (typeof document !== "undefined") return document.body;
+	return null;
+}
+function attachDelegatedListener(container, element, eventName, handler, originalHandler, options, fresh = false) {
+	const existingStore = fresh ? void 0 : getDelegatedHandlerStore(element);
+	const hadHandler = existingStore instanceof Map ? existingStore.has(eventName) : existingStore?.eventName === eventName;
+	let containerListeners = containerDelegatedListeners.get(container);
+	if (!containerListeners) {
+		containerListeners = /* @__PURE__ */ new Map();
+		containerDelegatedListeners.set(container, containerListeners);
+	}
+	let containerListener = containerListeners.get(eventName);
+	if (!containerListener) {
+		const delegatedHandler = (e) => {
+			const target = e.target;
+			if (!target) return;
+			runRuntimeHandlerScope(() => {
+				let current = target;
+				while (current && current !== container) {
+					const store = getDelegatedHandlerStore(current);
+					const entry = !store ? void 0 : store instanceof Map ? store.get(eventName) : store.eventName === eventName ? store : void 0;
+					if (entry) try {
+						entry.handler(e);
+					} catch (error) {
+						logger.error("[Askr] Delegated event error:", error);
+					}
+					if (e.cancelBubble) break;
+					current = current.parentElement;
+				}
+			}, "sync");
+		};
+		const listenerOptions = getPassiveOptions(eventName) ?? options;
+		container.addEventListener(eventName, delegatedHandler, listenerOptions);
+		containerListener = {
+			handler: delegatedHandler,
+			usage: 0
+		};
+		containerListeners.set(eventName, containerListener);
+	}
+	setDelegatedHandlerForElement(element, {
+		handler,
+		original: originalHandler,
+		container,
+		eventName,
+		options
+	}, existingStore);
+	if (!hadHandler) containerListener.usage += 1;
+}
+function setDelegatedHandlerForElement(element, entry, existing = getDelegatedHandlerStore(element)) {
+	if (!existing) {
+		setDelegatedHandlerStore(element, entry);
+		return;
+	}
+	if (existing instanceof Map) {
+		existing.set(entry.eventName, entry);
+		return;
+	}
+	if (existing.eventName === entry.eventName) {
+		setDelegatedHandlerStore(element, entry);
+		return;
+	}
+	const next = /* @__PURE__ */ new Map();
+	next.set(existing.eventName, existing);
+	next.set(entry.eventName, entry);
+	setDelegatedHandlerStore(element, next);
+}
+function getPassiveOptions(eventName) {
+	if (eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch")) return { passive: true };
+}
+function addDelegatedListener(element, eventName, handler, originalHandler, options) {
+	const container = getDelegationContainer();
+	if (!container) return;
+	attachDelegatedListener(container, element, eventName, handler, originalHandler, options);
+}
+/** @internal Attach a delegated handler to a newly cloned element. */
+function addFreshDelegatedListener(element, eventName, handler, originalHandler, options) {
+	const container = getDelegationContainer();
+	if (!container) return;
+	attachDelegatedListener(container, element, eventName, handler, originalHandler, options, true);
+}
+function updateDelegatedListener(element, eventName, handler, originalHandler, options) {
+	const existing = getDelegatedHandlerForElement(element, eventName);
+	if (!existing) return false;
+	const container = getDelegationContainer();
+	if (!container || existing.container !== container || !containerDelegatedListeners.get(existing.container)?.has(eventName)) {
+		removeDelegatedListener(element, eventName);
+		return false;
+	}
+	existing.handler = handler;
+	existing.original = originalHandler;
+	existing.options = options;
+	return true;
+}
+function removeDelegatedListener(element, eventName) {
+	const existing = getDelegatedHandlerStore(element);
+	if (!existing) return;
+	if (existing instanceof Map) {
+		if (existing.has(eventName)) decrementContainerListenerUsage(existing.get(eventName));
+		existing.delete(eventName);
+		if (existing.size === 0) {
+			deleteDelegatedHandlerStore(element);
+			return;
+		}
+		if (existing.size === 1) {
+			const only = existing.values().next().value;
+			setDelegatedHandlerStore(element, only);
+		}
+		return;
+	}
+	if (existing.eventName === eventName) {
+		decrementContainerListenerUsage(existing);
+		deleteDelegatedHandlerStore(element);
+	}
+}
+function getDelegatedHandlerForElement(element, eventName) {
+	const store = getDelegatedHandlerStore(element);
+	if (!store) return void 0;
+	if (store instanceof Map) return store.get(eventName);
+	return store.eventName === eventName ? store : void 0;
+}
+function getDelegatedHandlersForElement(element) {
+	const store = getDelegatedHandlerStore(element);
+	if (!store) return void 0;
+	if (store instanceof Map) return store;
+	return /* @__PURE__ */ new Map([[store.eventName, store]]);
+}
+function clearDelegatedHandlersForElement(element) {
+	const existing = getDelegatedHandlerStore(element);
+	if (existing instanceof Map) for (const entry of existing.values()) decrementContainerListenerUsage(entry);
+	else if (existing) decrementContainerListenerUsage(existing);
+	deleteDelegatedHandlerStore(element);
+}
+function isDelegatedEvent(eventName) {
+	return DELEGATED_EVENTS.includes(eventName);
+}
+//#endregion
+//#region src/renderer/cleanup.ts
+const elementRefs = /* @__PURE__ */ new WeakMap();
+const refOwners = /* @__PURE__ */ new WeakMap();
+function isRefOwnerKey(ref) {
+	return typeof ref === "function" || typeof ref === "object" && ref !== null;
+}
+/** @internal Return the current exact owner for ref reconciliation. */
+function getElementRefOwner(ref) {
+	return isRefOwnerKey(ref) ? refOwners.get(ref) : void 0;
+}
+/** @internal Synchronize ref registries without invoking user callbacks. */
+function replaceElementRefBookkeeping(element, ref) {
+	const previousRef = elementRefs.get(element);
+	if (isRefOwnerKey(previousRef) && refOwners.get(previousRef) === element) refOwners.delete(previousRef);
+	if (ref) {
+		elementRefs.set(element, ref);
+		if (isRefOwnerKey(ref)) refOwners.set(ref, element);
+	} else elementRefs.delete(element);
+}
+function applyRefValue(ref, value) {
+	const resolvedRef = ref;
+	if (!resolvedRef) return;
+	if (typeof resolvedRef === "function") {
+		resolvedRef(value);
+		return;
+	}
+	if (Object.isExtensible(resolvedRef)) resolvedRef.current = value;
+}
+function updateElementRef(element, ref) {
+	if (registerLifecycleTransaction({}, () => updateElementRefImmediately(element, ref), () => void 0)) return;
+	updateElementRefImmediately(element, ref);
+}
+function updateElementRefImmediately(element, ref) {
+	const previousRef = elementRefs.get(element);
+	if (previousRef === ref) return;
+	if (previousRef) {
+		applyRefValue(previousRef, null);
+		if (getElementRefOwner(previousRef) === element) refOwners.delete(previousRef);
+	}
+	if (ref) {
+		const previousOwner = getElementRefOwner(ref);
+		if (typeof ref === "function" && previousOwner && previousOwner !== element) {
+			elementRefs.set(element, ref);
+			refOwners.set(ref, element);
+			return;
+		}
+		applyRefValue(ref, element);
+		elementRefs.set(element, ref);
+		if (isRefOwnerKey(ref)) refOwners.set(ref, element);
+	} else elementRefs.delete(element);
+}
+function removeElementRef(element) {
+	const ref = elementRefs.get(element);
+	if (!ref) return;
+	if (typeof ref !== "function" && getElementRefOwner(ref) !== element) {
+		elementRefs.delete(element);
+		return;
+	}
+	applyRefValue(ref, null);
+	const nextOwner = getElementRefOwner(ref);
+	if (typeof ref === "function" && nextOwner && nextOwner !== element) applyRefValue(ref, nextOwner);
+	replaceElementRefBookkeeping(element, void 0);
+}
+function cleanupSingleInstance(node, errors, strict) {
+	const instanceList = node.__ASKR_INSTANCES;
+	const primaryInstance = node.__ASKR_INSTANCE;
+	if (!instanceList && !primaryInstance) return;
+	const instances = /* @__PURE__ */ new Set();
+	if (Array.isArray(instanceList)) {
+		for (const instance of instanceList) if (instance) instances.add(instance);
+	}
+	if (primaryInstance) instances.add(primaryInstance);
+	for (const instance of instances) try {
+		cleanupComponent(instance);
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] cleanupComponent failed:", err);
+	}
+	try {
+		delete node.__ASKR_INSTANCE;
+		delete node.__ASKR_INSTANCES;
+	} catch (e) {
+		if (strict) errors.push(e);
+	}
+}
+function teardownSingleElement(element, errors, strict) {
+	try {
+		removeElementRef(element);
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] removeElementRef failed:", err);
+	}
+	try {
+		removeElementListeners(element);
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] removeElementListeners failed:", err);
+	}
+	try {
+		removeElementReactiveProps(element);
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] removeElementReactiveProps failed:", err);
+	}
+	try {
+		cleanupSingleInstance(element, errors, strict);
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] cleanupSingleInstance failed:", err);
+	}
+}
+function forEachDescendantElement(root, visit) {
+	try {
+		const doc = root.ownerDocument;
+		const createTreeWalker = doc?.createTreeWalker;
+		if (typeof createTreeWalker === "function") {
+			const walker = createTreeWalker.call(doc, root, 1);
+			let n = walker.firstChild();
+			while (n) {
+				visit(n);
+				n = walker.nextNode();
+			}
+			return;
+		}
+	} catch {}
+	const descendants = root.querySelectorAll("*");
+	for (let i = 0; i < descendants.length; i++) visit(descendants[i]);
+}
+/** @internal Walk every descendant node, including component-host comments. */
+function forEachDescendantNode(root, visit) {
+	try {
+		const doc = root.ownerDocument;
+		const createTreeWalker = doc?.createTreeWalker;
+		if (typeof createTreeWalker === "function") {
+			const walker = createTreeWalker.call(doc, root, 4294967295);
+			let node = walker.nextNode();
+			while (node) {
+				visit(node);
+				node = walker.nextNode();
+			}
+			return;
+		}
+	} catch {}
+	const stack = Array.from(root.childNodes).reverse();
+	while (stack.length > 0) {
+		const node = stack.pop();
+		visit(node);
+		for (let child = node.lastChild; child; child = child.previousSibling) stack.push(child);
+	}
+}
+function forEachElementInSubtree(root, visit) {
+	visit(root);
+	forEachDescendantElement(root, visit);
+}
+const elementListeners = /* @__PURE__ */ new WeakMap();
+/**
+* Clean up component instance attached to a DOM node
+* Accepts an optional `opts.strict` flag to surface errors instead of swallowing them.
+*/
+function cleanupInstanceIfPresent(node, opts) {
+	if (!node) return;
+	const strict = opts?.strict ?? false;
+	const errors = strict ? [] : null;
+	try {
+		cleanupSingleInstance(node, errors, strict);
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
+	}
+	try {
+		forEachDescendantNode(node, (descendant) => {
+			try {
+				cleanupSingleInstance(descendant, errors, strict);
+			} catch (err) {
+				if (strict) errors.push(err);
+				else logger.warn("[Askr] cleanupInstanceIfPresent descendant cleanup failed:", err);
+			}
+		});
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] cleanupInstanceIfPresent descendant query failed:", err);
+	}
+	if (errors && errors.length > 0) throw new AggregateError(errors, "cleanupInstanceIfPresent failed");
+}
+function cleanupInstancesUnder(node, opts) {
+	cleanupInstanceIfPresent(node, opts);
+}
+function teardownNodeSubtree(node, opts) {
+	if (!node) return;
+	const strict = opts?.strict ?? false;
+	const errors = strict ? [] : null;
+	if (!(node instanceof Element)) {
+		cleanupSingleInstance(node, errors, strict);
+		if (errors && errors.length > 0) throw new AggregateError(errors, "teardownNodeSubtree failed");
+		return;
+	}
+	try {
+		teardownSingleElement(node, errors, strict);
+		forEachDescendantNode(node, (descendant) => {
+			if (descendant instanceof Element) teardownSingleElement(descendant, errors, strict);
+			else cleanupSingleInstance(descendant, errors, strict);
+		});
+	} catch (err) {
+		if (strict) errors.push(err);
+		else logger.warn("[Askr] teardownNodeSubtree failed:", err);
+	}
+	if (errors && errors.length > 0) throw new AggregateError(errors, "teardownNodeSubtree failed");
+}
+const REACTIVE_CHILDREN_KEY = "__askr_reactive_children__";
+const elementReactivePropsCleanup = /* @__PURE__ */ new WeakMap();
+function getElementReactivePropsCleanupMap(element, create = false) {
+	const store = elementReactivePropsCleanup.get(element);
+	if (store instanceof Map) return store;
+	if (store) {
+		const map = /* @__PURE__ */ new Map([[store._bindingKey, store]]);
+		elementReactivePropsCleanup.set(element, map);
+		return map;
+	}
+	if (!create) return;
+	const map = /* @__PURE__ */ new Map();
+	elementReactivePropsCleanup.set(element, map);
+	return map;
+}
+function setDirectElementReactivePropCleanup(element, bindingKey, entry) {
+	if (!elementReactivePropsCleanup.get(element)) {
+		entry._bindingKey = bindingKey;
+		elementReactivePropsCleanup.set(element, entry);
+		return;
+	}
+	getElementReactivePropsCleanupMap(element, true).set(bindingKey, entry);
+}
+/** @internal Publish the first reactive binding on a newly created element. */
+function setFreshElementReactivePropCleanup(element, bindingKey, entry) {
+	entry._bindingKey = bindingKey;
+	elementReactivePropsCleanup.set(element, entry);
+}
+function getElementReactivePropCleanupSize(element) {
+	const store = elementReactivePropsCleanup.get(element);
+	return store instanceof Map ? store.size : store ? 1 : 0;
+}
+function forEachElementReactivePropCleanup(element, visit) {
+	const store = elementReactivePropsCleanup.get(element);
+	if (store instanceof Map) for (const entry of store.values()) visit(entry);
+	else if (store) visit(store);
+}
+function removeElementReactiveProps(element) {
+	if (elementReactivePropsCleanup.has(element)) {
+		forEachElementReactivePropCleanup(element, (entry) => {
+			try {
+				entry.cleanup();
+			} catch (err) {
+				logger.warn("[Askr] reactive prop cleanup failed:", err);
+			}
+		});
+		elementReactivePropsCleanup.delete(element);
+	}
+}
+function removeElementListeners(element) {
+	const map = elementListeners.get(element);
+	if (map) {
+		for (const entry of map.values()) if (entry.isDelegated) removeDelegatedListener(element, entry.eventName);
+		else if (entry.options !== void 0) element.removeEventListener(entry.eventName, entry.handler, entry.options);
+		else element.removeEventListener(entry.eventName, entry.handler);
+		elementListeners.delete(element);
+	}
+	clearDelegatedHandlersForElement(element);
+}
+function removeAllListeners(root) {
+	if (!root) return;
+	forEachElementInSubtree(root, (el) => {
+		removeElementRef(el);
+		removeElementListeners(el);
+		removeElementReactiveProps(el);
+	});
+}
+//#endregion
+export { getDelegatedHandlersForElement as C, updateDelegatedListener as D, removeDelegatedListener as E, getDelegatedHandlerForElement as S, isEventDelegationEnabled as T, teardownNodeSubtree as _, elementReactivePropsCleanup as a, addFreshDelegatedListener as b, forEachElementReactivePropCleanup as c, removeAllListeners as d, removeElementReactiveProps as f, setFreshElementReactivePropCleanup as g, setDirectElementReactivePropCleanup as h, elementListeners as i, getElementReactivePropCleanupSize as l, replaceElementRefBookkeeping as m, cleanupInstanceIfPresent as n, elementRefs as o, removeElementRef as p, cleanupInstancesUnder as r, forEachDescendantNode as s, REACTIVE_CHILDREN_KEY as t, getElementReactivePropsCleanupMap as u, updateElementRef as v, isDelegatedEvent as w, clearDelegatedHandlersForElement as x, addDelegatedListener as y };