tanstack-router-cache 0.1.6 → 0.1.8

package/dist/dom/dismiss-transient-ui.cjs

@@ -0,0 +1,230 @@
+//#region src/dom/dismiss-transient-ui.ts
+const documentStates = /* @__PURE__ */ new WeakMap();
+const PERSISTENT_EXTERNAL_ATTRIBUTE = "data-router-cache-persistent-external";
+function isBlurTarget(element) {
+	return element instanceof HTMLElement;
+}
+function getOrCreateDocumentState(documentObject) {
+	const existingState = documentStates.get(documentObject);
+	if (existingState) return existingState;
+	const state = {
+		observer: null,
+		ownerByElement: /* @__PURE__ */ new WeakMap(),
+		routes: /* @__PURE__ */ new Map(),
+		visiblePathname: null
+	};
+	if (typeof MutationObserver !== "undefined") {
+		state.observer = new MutationObserver((mutations) => {
+			handleDomMutations(mutations, state);
+		});
+		state.observer.observe(documentObject.body ?? documentObject.documentElement, {
+			childList: true,
+			subtree: true
+		});
+	}
+	documentStates.set(documentObject, state);
+	return state;
+}
+function getOrCreateRouteState(state, pathname) {
+	const existingRouteState = state.routes.get(pathname);
+	if (existingRouteState) return existingRouteState;
+	const routeState = {
+		hiddenElements: /* @__PURE__ */ new Map(),
+		ownedElements: /* @__PURE__ */ new Set()
+	};
+	state.routes.set(pathname, routeState);
+	return routeState;
+}
+function getHoveredElements(documentObject) {
+	try {
+		return Array.from(documentObject.querySelectorAll(":hover")).reverse();
+	} catch {
+		return [];
+	}
+}
+function getOwnedExternalElements(documentObject, pathname) {
+	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
+	return Array.from(routeState.ownedElements).filter((element) => element.isConnected);
+}
+function dispatchEscapeKeyboardEvent(target, documentObject, type) {
+	const keyboardEventConstructor = documentObject.defaultView?.KeyboardEvent ?? KeyboardEvent;
+	target.dispatchEvent(new keyboardEventConstructor(type, {
+		bubbles: true,
+		cancelable: true,
+		code: "Escape",
+		key: "Escape",
+		keyCode: 27,
+		which: 27
+	}));
+}
+function dispatchHoverExitEvent(target, documentObject, type) {
+	const eventConstructor = type.startsWith("pointer") ? documentObject.defaultView?.PointerEvent ?? documentObject.defaultView?.MouseEvent ?? MouseEvent : documentObject.defaultView?.MouseEvent ?? MouseEvent;
+	target.dispatchEvent(new eventConstructor(type, {
+		bubbles: type.endsWith("out"),
+		cancelable: true,
+		composed: true,
+		relatedTarget: documentObject.body
+	}));
+}
+function dispatchHoverExitEvents(hoveredElements, documentObject) {
+	for (const hoveredElement of hoveredElements) {
+		dispatchHoverExitEvent(hoveredElement, documentObject, "pointerout");
+		dispatchHoverExitEvent(hoveredElement, documentObject, "pointerleave");
+		dispatchHoverExitEvent(hoveredElement, documentObject, "mouseout");
+		dispatchHoverExitEvent(hoveredElement, documentObject, "mouseleave");
+	}
+}
+function focusDocumentBody(documentObject) {
+	const { body } = documentObject;
+	const previousTabIndex = body.getAttribute("tabindex");
+	if (previousTabIndex === null) body.setAttribute("tabindex", "-1");
+	body.focus();
+	if (previousTabIndex === null) body.removeAttribute("tabindex");
+}
+function getRouterCacheContainerAncestor(element) {
+	const container = element?.closest("[data-router-cache-container=\"true\"]");
+	return container instanceof HTMLElement ? container : null;
+}
+function isElementInsideAnyRouterCacheContainer(element) {
+	return getRouterCacheContainerAncestor(element) !== null;
+}
+function containsRouterCacheContainer(element) {
+	return element.querySelector("[data-router-cache-container=\"true\"]") instanceof HTMLElement;
+}
+function isElementConnectedOutsideRouterCacheContainer(element) {
+	return element.isConnected && !isElementInsideAnyRouterCacheContainer(element);
+}
+function isPersistentExternalElement(element) {
+	return element.closest(`[${PERSISTENT_EXTERNAL_ATTRIBUTE}="true"]`) instanceof HTMLElement;
+}
+function getTrackableElementsFromNode(node) {
+	if (node instanceof HTMLElement) return [node];
+	if (node instanceof DocumentFragment) return Array.from(node.children).flatMap((child) => child instanceof HTMLElement ? [child] : []);
+	return [];
+}
+function forEachRemovedNode(mutations, callback) {
+	for (const mutation of mutations) for (const removedNode of mutation.removedNodes) callback(removedNode);
+}
+function forEachAddedNode(mutations, callback) {
+	for (const mutation of mutations) for (const addedNode of mutation.addedNodes) callback(addedNode);
+}
+function handleDomMutations(mutations, state) {
+	forEachRemovedNode(mutations, (removedNode) => {
+		untrackRemovedNode(removedNode, state);
+	});
+	if (!state.visiblePathname) return;
+	forEachAddedNode(mutations, (addedNode) => {
+		trackAddedNode(addedNode, state.visiblePathname, state);
+	});
+}
+function hasTrackedAncestor(element, state) {
+	let ancestor = element.parentElement;
+	while (ancestor) {
+		if (state.ownerByElement.get(ancestor)) return true;
+		ancestor = ancestor.parentElement;
+	}
+	return false;
+}
+function restoreOwnedExternalElement(routeState, element) {
+	const snapshot = routeState.hiddenElements.get(element);
+	if (!snapshot) return;
+	element.style.setProperty("display", snapshot.display, snapshot.displayPriority);
+	if (snapshot.ariaHidden === null) element.removeAttribute("aria-hidden");
+	else element.setAttribute("aria-hidden", snapshot.ariaHidden);
+	element.inert = snapshot.inert;
+	routeState.hiddenElements.delete(element);
+}
+function trackExternalElement(pathname, element, state) {
+	if (!isElementConnectedOutsideRouterCacheContainer(element) || containsRouterCacheContainer(element) || isPersistentExternalElement(element) || hasTrackedAncestor(element, state)) return;
+	const currentOwner = state.ownerByElement.get(element);
+	if (currentOwner === pathname) return;
+	if (currentOwner) {
+		const previousRouteState = state.routes.get(currentOwner);
+		if (previousRouteState) {
+			restoreOwnedExternalElement(previousRouteState, element);
+			previousRouteState.ownedElements.delete(element);
+		}
+	}
+	getOrCreateRouteState(state, pathname).ownedElements.add(element);
+	state.ownerByElement.set(element, pathname);
+}
+function trackAddedNode(node, pathname, state) {
+	const elements = getTrackableElementsFromNode(node);
+	for (const element of elements) trackExternalElement(pathname, element, state);
+}
+function untrackElement(routeState, state, element) {
+	routeState.hiddenElements.delete(element);
+	routeState.ownedElements.delete(element);
+	state.ownerByElement.delete(element);
+}
+function untrackRemovedNode(node, state) {
+	if (!(node instanceof HTMLElement)) return;
+	for (const routeState of state.routes.values()) for (const element of Array.from(routeState.ownedElements)) if (node === element || node.contains(element)) untrackElement(routeState, state, element);
+}
+function hideOwnedExternalElements(documentObject, pathname) {
+	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
+	for (const element of Array.from(routeState.ownedElements)) {
+		if (!isElementConnectedOutsideRouterCacheContainer(element)) {
+			routeState.ownedElements.delete(element);
+			routeState.hiddenElements.delete(element);
+			continue;
+		}
+		if (routeState.hiddenElements.has(element)) continue;
+		routeState.hiddenElements.set(element, {
+			ariaHidden: element.getAttribute("aria-hidden"),
+			display: element.style.getPropertyValue("display"),
+			displayPriority: element.style.getPropertyPriority("display"),
+			inert: element.inert
+		});
+		element.style.setProperty("display", "none", "important");
+		element.setAttribute("aria-hidden", "true");
+		element.inert = true;
+	}
+}
+function showOwnedExternalElements(documentObject, pathname) {
+	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
+	for (const [element] of Array.from(routeState.hiddenElements)) {
+		if (!element.isConnected) {
+			routeState.hiddenElements.delete(element);
+			routeState.ownedElements.delete(element);
+			continue;
+		}
+		restoreOwnedExternalElement(routeState, element);
+	}
+}
+function initializeTransientUiTracking(documentObject) {
+	getOrCreateDocumentState(documentObject);
+}
+function syncTransientUiRouteActivity(pathname, mode) {
+	if (typeof document === "undefined") return;
+	const documentState = getOrCreateDocumentState(document);
+	getOrCreateRouteState(documentState, pathname);
+	if (mode === "visible") {
+		documentState.visiblePathname = pathname;
+		showOwnedExternalElements(document, pathname);
+		return;
+	}
+	if (documentState.visiblePathname === pathname) documentState.visiblePathname = null;
+	dispatchHoverExitEvents(getOwnedExternalElements(document, pathname), document);
+	hideOwnedExternalElements(document, pathname);
+}
+function dismissTransientUi(container, pathname) {
+	if (typeof document === "undefined" || !container) return;
+	initializeTransientUiTracking(document);
+	const hoveredElements = getHoveredElements(document);
+	const hoverExitTargets = Array.from(/* @__PURE__ */ new Set([...hoveredElements, ...getOwnedExternalElements(document, pathname)]));
+	const activeElement = document.activeElement;
+	const activeElementBelongsToHoveredTree = activeElement instanceof Element && hoverExitTargets.some((hoveredElement) => hoveredElement === activeElement || hoveredElement.contains(activeElement));
+	if (activeElement instanceof Element && (container.contains(activeElement) || activeElementBelongsToHoveredTree) && isBlurTarget(activeElement)) activeElement.blur();
+	dispatchHoverExitEvents(hoverExitTargets, document);
+	dispatchEscapeKeyboardEvent(document, document, "keydown");
+	dispatchEscapeKeyboardEvent(document, document, "keyup");
+	hideOwnedExternalElements(document, pathname);
+	const nextActiveElement = document.activeElement;
+	const nextActiveElementBelongsToHoveredTree = nextActiveElement instanceof Element && hoverExitTargets.some((hoveredElement) => hoveredElement === nextActiveElement || hoveredElement.contains(nextActiveElement));
+	if (nextActiveElement instanceof Element && (container.contains(nextActiveElement) || nextActiveElementBelongsToHoveredTree)) focusDocumentBody(document);
+}
+//#endregion
+exports.dismissTransientUi = dismissTransientUi;
+exports.initializeTransientUiTracking = initializeTransientUiTracking;
+exports.syncTransientUiRouteActivity = syncTransientUiRouteActivity;

package/dist/dom/dismiss-transient-ui.js

@@ -0,0 +1,228 @@
+//#region src/dom/dismiss-transient-ui.ts
+const documentStates = /* @__PURE__ */ new WeakMap();
+const PERSISTENT_EXTERNAL_ATTRIBUTE = "data-router-cache-persistent-external";
+function isBlurTarget(element) {
+	return element instanceof HTMLElement;
+}
+function getOrCreateDocumentState(documentObject) {
+	const existingState = documentStates.get(documentObject);
+	if (existingState) return existingState;
+	const state = {
+		observer: null,
+		ownerByElement: /* @__PURE__ */ new WeakMap(),
+		routes: /* @__PURE__ */ new Map(),
+		visiblePathname: null
+	};
+	if (typeof MutationObserver !== "undefined") {
+		state.observer = new MutationObserver((mutations) => {
+			handleDomMutations(mutations, state);
+		});
+		state.observer.observe(documentObject.body ?? documentObject.documentElement, {
+			childList: true,
+			subtree: true
+		});
+	}
+	documentStates.set(documentObject, state);
+	return state;
+}
+function getOrCreateRouteState(state, pathname) {
+	const existingRouteState = state.routes.get(pathname);
+	if (existingRouteState) return existingRouteState;
+	const routeState = {
+		hiddenElements: /* @__PURE__ */ new Map(),
+		ownedElements: /* @__PURE__ */ new Set()
+	};
+	state.routes.set(pathname, routeState);
+	return routeState;
+}
+function getHoveredElements(documentObject) {
+	try {
+		return Array.from(documentObject.querySelectorAll(":hover")).reverse();
+	} catch {
+		return [];
+	}
+}
+function getOwnedExternalElements(documentObject, pathname) {
+	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
+	return Array.from(routeState.ownedElements).filter((element) => element.isConnected);
+}
+function dispatchEscapeKeyboardEvent(target, documentObject, type) {
+	const keyboardEventConstructor = documentObject.defaultView?.KeyboardEvent ?? KeyboardEvent;
+	target.dispatchEvent(new keyboardEventConstructor(type, {
+		bubbles: true,
+		cancelable: true,
+		code: "Escape",
+		key: "Escape",
+		keyCode: 27,
+		which: 27
+	}));
+}
+function dispatchHoverExitEvent(target, documentObject, type) {
+	const eventConstructor = type.startsWith("pointer") ? documentObject.defaultView?.PointerEvent ?? documentObject.defaultView?.MouseEvent ?? MouseEvent : documentObject.defaultView?.MouseEvent ?? MouseEvent;
+	target.dispatchEvent(new eventConstructor(type, {
+		bubbles: type.endsWith("out"),
+		cancelable: true,
+		composed: true,
+		relatedTarget: documentObject.body
+	}));
+}
+function dispatchHoverExitEvents(hoveredElements, documentObject) {
+	for (const hoveredElement of hoveredElements) {
+		dispatchHoverExitEvent(hoveredElement, documentObject, "pointerout");
+		dispatchHoverExitEvent(hoveredElement, documentObject, "pointerleave");
+		dispatchHoverExitEvent(hoveredElement, documentObject, "mouseout");
+		dispatchHoverExitEvent(hoveredElement, documentObject, "mouseleave");
+	}
+}
+function focusDocumentBody(documentObject) {
+	const { body } = documentObject;
+	const previousTabIndex = body.getAttribute("tabindex");
+	if (previousTabIndex === null) body.setAttribute("tabindex", "-1");
+	body.focus();
+	if (previousTabIndex === null) body.removeAttribute("tabindex");
+}
+function getRouterCacheContainerAncestor(element) {
+	const container = element?.closest("[data-router-cache-container=\"true\"]");
+	return container instanceof HTMLElement ? container : null;
+}
+function isElementInsideAnyRouterCacheContainer(element) {
+	return getRouterCacheContainerAncestor(element) !== null;
+}
+function containsRouterCacheContainer(element) {
+	return element.querySelector("[data-router-cache-container=\"true\"]") instanceof HTMLElement;
+}
+function isElementConnectedOutsideRouterCacheContainer(element) {
+	return element.isConnected && !isElementInsideAnyRouterCacheContainer(element);
+}
+function isPersistentExternalElement(element) {
+	return element.closest(`[${PERSISTENT_EXTERNAL_ATTRIBUTE}="true"]`) instanceof HTMLElement;
+}
+function getTrackableElementsFromNode(node) {
+	if (node instanceof HTMLElement) return [node];
+	if (node instanceof DocumentFragment) return Array.from(node.children).flatMap((child) => child instanceof HTMLElement ? [child] : []);
+	return [];
+}
+function forEachRemovedNode(mutations, callback) {
+	for (const mutation of mutations) for (const removedNode of mutation.removedNodes) callback(removedNode);
+}
+function forEachAddedNode(mutations, callback) {
+	for (const mutation of mutations) for (const addedNode of mutation.addedNodes) callback(addedNode);
+}
+function handleDomMutations(mutations, state) {
+	forEachRemovedNode(mutations, (removedNode) => {
+		untrackRemovedNode(removedNode, state);
+	});
+	if (!state.visiblePathname) return;
+	forEachAddedNode(mutations, (addedNode) => {
+		trackAddedNode(addedNode, state.visiblePathname, state);
+	});
+}
+function hasTrackedAncestor(element, state) {
+	let ancestor = element.parentElement;
+	while (ancestor) {
+		if (state.ownerByElement.get(ancestor)) return true;
+		ancestor = ancestor.parentElement;
+	}
+	return false;
+}
+function restoreOwnedExternalElement(routeState, element) {
+	const snapshot = routeState.hiddenElements.get(element);
+	if (!snapshot) return;
+	element.style.setProperty("display", snapshot.display, snapshot.displayPriority);
+	if (snapshot.ariaHidden === null) element.removeAttribute("aria-hidden");
+	else element.setAttribute("aria-hidden", snapshot.ariaHidden);
+	element.inert = snapshot.inert;
+	routeState.hiddenElements.delete(element);
+}
+function trackExternalElement(pathname, element, state) {
+	if (!isElementConnectedOutsideRouterCacheContainer(element) || containsRouterCacheContainer(element) || isPersistentExternalElement(element) || hasTrackedAncestor(element, state)) return;
+	const currentOwner = state.ownerByElement.get(element);
+	if (currentOwner === pathname) return;
+	if (currentOwner) {
+		const previousRouteState = state.routes.get(currentOwner);
+		if (previousRouteState) {
+			restoreOwnedExternalElement(previousRouteState, element);
+			previousRouteState.ownedElements.delete(element);
+		}
+	}
+	getOrCreateRouteState(state, pathname).ownedElements.add(element);
+	state.ownerByElement.set(element, pathname);
+}
+function trackAddedNode(node, pathname, state) {
+	const elements = getTrackableElementsFromNode(node);
+	for (const element of elements) trackExternalElement(pathname, element, state);
+}
+function untrackElement(routeState, state, element) {
+	routeState.hiddenElements.delete(element);
+	routeState.ownedElements.delete(element);
+	state.ownerByElement.delete(element);
+}
+function untrackRemovedNode(node, state) {
+	if (!(node instanceof HTMLElement)) return;
+	for (const routeState of state.routes.values()) for (const element of Array.from(routeState.ownedElements)) if (node === element || node.contains(element)) untrackElement(routeState, state, element);
+}
+function hideOwnedExternalElements(documentObject, pathname) {
+	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
+	for (const element of Array.from(routeState.ownedElements)) {
+		if (!isElementConnectedOutsideRouterCacheContainer(element)) {
+			routeState.ownedElements.delete(element);
+			routeState.hiddenElements.delete(element);
+			continue;
+		}
+		if (routeState.hiddenElements.has(element)) continue;
+		routeState.hiddenElements.set(element, {
+			ariaHidden: element.getAttribute("aria-hidden"),
+			display: element.style.getPropertyValue("display"),
+			displayPriority: element.style.getPropertyPriority("display"),
+			inert: element.inert
+		});
+		element.style.setProperty("display", "none", "important");
+		element.setAttribute("aria-hidden", "true");
+		element.inert = true;
+	}
+}
+function showOwnedExternalElements(documentObject, pathname) {
+	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
+	for (const [element] of Array.from(routeState.hiddenElements)) {
+		if (!element.isConnected) {
+			routeState.hiddenElements.delete(element);
+			routeState.ownedElements.delete(element);
+			continue;
+		}
+		restoreOwnedExternalElement(routeState, element);
+	}
+}
+function initializeTransientUiTracking(documentObject) {
+	getOrCreateDocumentState(documentObject);
+}
+function syncTransientUiRouteActivity(pathname, mode) {
+	if (typeof document === "undefined") return;
+	const documentState = getOrCreateDocumentState(document);
+	getOrCreateRouteState(documentState, pathname);
+	if (mode === "visible") {
+		documentState.visiblePathname = pathname;
+		showOwnedExternalElements(document, pathname);
+		return;
+	}
+	if (documentState.visiblePathname === pathname) documentState.visiblePathname = null;
+	dispatchHoverExitEvents(getOwnedExternalElements(document, pathname), document);
+	hideOwnedExternalElements(document, pathname);
+}
+function dismissTransientUi(container, pathname) {
+	if (typeof document === "undefined" || !container) return;
+	initializeTransientUiTracking(document);
+	const hoveredElements = getHoveredElements(document);
+	const hoverExitTargets = Array.from(/* @__PURE__ */ new Set([...hoveredElements, ...getOwnedExternalElements(document, pathname)]));
+	const activeElement = document.activeElement;
+	const activeElementBelongsToHoveredTree = activeElement instanceof Element && hoverExitTargets.some((hoveredElement) => hoveredElement === activeElement || hoveredElement.contains(activeElement));
+	if (activeElement instanceof Element && (container.contains(activeElement) || activeElementBelongsToHoveredTree) && isBlurTarget(activeElement)) activeElement.blur();
+	dispatchHoverExitEvents(hoverExitTargets, document);
+	dispatchEscapeKeyboardEvent(document, document, "keydown");
+	dispatchEscapeKeyboardEvent(document, document, "keyup");
+	hideOwnedExternalElements(document, pathname);
+	const nextActiveElement = document.activeElement;
+	const nextActiveElementBelongsToHoveredTree = nextActiveElement instanceof Element && hoverExitTargets.some((hoveredElement) => hoveredElement === nextActiveElement || hoveredElement.contains(nextActiveElement));
+	if (nextActiveElement instanceof Element && (container.contains(nextActiveElement) || nextActiveElementBelongsToHoveredTree)) focusDocumentBody(document);
+}
+//#endregion
+export { dismissTransientUi, initializeTransientUiTracking, syncTransientUiRouteActivity };

package/dist/hooks/use-event-listener.cjs

@@ -0,0 +1,76 @@
+let react = require("react");
+//#region src/hooks/use-event-listener.ts
+const EVENT_BUCKET_KEYS = ["on", "once"];
+const instance = class RouterCacheEvent {
+	static instance;
+	listeners = {
+		activeChange: /* @__PURE__ */ new Set(),
+		cachedNavigationCancel: /* @__PURE__ */ new Set(),
+		cachedNavigationComplete: /* @__PURE__ */ new Set(),
+		cachedNavigationStart: /* @__PURE__ */ new Set()
+	};
+	constructor() {}
+	static getInstance() {
+		if (!RouterCacheEvent.instance) RouterCacheEvent.instance = new RouterCacheEvent();
+		return RouterCacheEvent.instance;
+	}
+	on(eventName, handler) {
+		this.listeners[eventName].add(handler);
+		return this;
+	}
+	once(eventName, handler) {
+		const onceHandler = (...args) => {
+			this.off(eventName, onceHandler);
+			handler(...args);
+		};
+		this.listeners[eventName].add(onceHandler);
+		return this;
+	}
+	off(eventName, handler) {
+		this.listeners[eventName].delete(handler);
+		return this;
+	}
+	emit(eventName, ...args) {
+		const handlers = this.listeners[eventName];
+		for (const handler of handlers) handler(...args);
+		return handlers.size > 0;
+	}
+}.getInstance();
+function syncEventHandler(type, eventName, handler) {
+	if (type === "on") {
+		instance.on(eventName, handler);
+		return;
+	}
+	instance.off(eventName, handler);
+}
+function syncEventBucket(type, bucket) {
+	if (bucket.activeChange) syncEventHandler(type, "activeChange", bucket.activeChange);
+	if (bucket.cachedNavigationCancel) syncEventHandler(type, "cachedNavigationCancel", bucket.cachedNavigationCancel);
+	if (bucket.cachedNavigationComplete) syncEventHandler(type, "cachedNavigationComplete", bucket.cachedNavigationComplete);
+	if (bucket.cachedNavigationStart) syncEventHandler(type, "cachedNavigationStart", bucket.cachedNavigationStart);
+}
+function syncEventHandlers(type, events) {
+	if (!events) return;
+	for (const key of EVENT_BUCKET_KEYS) {
+		const bucket = events[key];
+		if (!bucket) continue;
+		syncEventBucket(type, bucket);
+	}
+}
+function useEventListener(events) {
+	(0, react.useEffect)(() => {
+		const registerEvent = () => {
+			syncEventHandlers("on", events);
+			return () => {
+				syncEventHandlers("off", events);
+			};
+		};
+		const unregister = registerEvent();
+		return () => {
+			unregister?.();
+		};
+	}, [events]);
+	return { eventListener: instance };
+}
+//#endregion
+exports.useEventListener = useEventListener;

package/dist/hooks/use-event-listener.js

@@ -0,0 +1,76 @@
+import { useEffect } from "react";
+//#region src/hooks/use-event-listener.ts
+const EVENT_BUCKET_KEYS = ["on", "once"];
+const instance = class RouterCacheEvent {
+	static instance;
+	listeners = {
+		activeChange: /* @__PURE__ */ new Set(),
+		cachedNavigationCancel: /* @__PURE__ */ new Set(),
+		cachedNavigationComplete: /* @__PURE__ */ new Set(),
+		cachedNavigationStart: /* @__PURE__ */ new Set()
+	};
+	constructor() {}
+	static getInstance() {
+		if (!RouterCacheEvent.instance) RouterCacheEvent.instance = new RouterCacheEvent();
+		return RouterCacheEvent.instance;
+	}
+	on(eventName, handler) {
+		this.listeners[eventName].add(handler);
+		return this;
+	}
+	once(eventName, handler) {
+		const onceHandler = (...args) => {
+			this.off(eventName, onceHandler);
+			handler(...args);
+		};
+		this.listeners[eventName].add(onceHandler);
+		return this;
+	}
+	off(eventName, handler) {
+		this.listeners[eventName].delete(handler);
+		return this;
+	}
+	emit(eventName, ...args) {
+		const handlers = this.listeners[eventName];
+		for (const handler of handlers) handler(...args);
+		return handlers.size > 0;
+	}
+}.getInstance();
+function syncEventHandler(type, eventName, handler) {
+	if (type === "on") {
+		instance.on(eventName, handler);
+		return;
+	}
+	instance.off(eventName, handler);
+}
+function syncEventBucket(type, bucket) {
+	if (bucket.activeChange) syncEventHandler(type, "activeChange", bucket.activeChange);
+	if (bucket.cachedNavigationCancel) syncEventHandler(type, "cachedNavigationCancel", bucket.cachedNavigationCancel);
+	if (bucket.cachedNavigationComplete) syncEventHandler(type, "cachedNavigationComplete", bucket.cachedNavigationComplete);
+	if (bucket.cachedNavigationStart) syncEventHandler(type, "cachedNavigationStart", bucket.cachedNavigationStart);
+}
+function syncEventHandlers(type, events) {
+	if (!events) return;
+	for (const key of EVENT_BUCKET_KEYS) {
+		const bucket = events[key];
+		if (!bucket) continue;
+		syncEventBucket(type, bucket);
+	}
+}
+function useEventListener(events) {
+	useEffect(() => {
+		const registerEvent = () => {
+			syncEventHandlers("on", events);
+			return () => {
+				syncEventHandlers("off", events);
+			};
+		};
+		const unregister = registerEvent();
+		return () => {
+			unregister?.();
+		};
+	}, [events]);
+	return { eventListener: instance };
+}
+//#endregion
+export { useEventListener };

package/dist/hooks/use-route-cache-active.cjs

@@ -0,0 +1,19 @@
+const require_pathname = require("../pathname.cjs");
+const require_use_event_listener = require("./use-event-listener.cjs");
+let _tanstack_react_router = require("@tanstack/react-router");
+let react = require("react");
+//#region src/hooks/use-route-cache-active.ts
+function useRoutePathname(pathname) {
+	const locationPathname = (0, _tanstack_react_router.useLocation)({ select: (location) => location.pathname });
+	return require_pathname.normalizeCachedRoutePathname(pathname ?? locationPathname);
+}
+function useRouteCacheActive(pathname) {
+	const routePathname = useRoutePathname(pathname);
+	const [isActive, setIsActive] = (0, react.useState)(true);
+	require_use_event_listener.useEventListener({ on: { activeChange: ({ pathname: changedPathname, mode }) => {
+		if (changedPathname === routePathname) setIsActive(mode === "visible");
+	} } });
+	return isActive;
+}
+//#endregion
+exports.useRouteCacheActive = useRouteCacheActive;

package/dist/hooks/use-route-cache-active.js

@@ -0,0 +1,19 @@
+import { normalizeCachedRoutePathname } from "../pathname.js";
+import { useEventListener } from "./use-event-listener.js";
+import { useLocation } from "@tanstack/react-router";
+import { useState } from "react";
+//#region src/hooks/use-route-cache-active.ts
+function useRoutePathname(pathname) {
+	const locationPathname = useLocation({ select: (location) => location.pathname });
+	return normalizeCachedRoutePathname(pathname ?? locationPathname);
+}
+function useRouteCacheActive(pathname) {
+	const routePathname = useRoutePathname(pathname);
+	const [isActive, setIsActive] = useState(true);
+	useEventListener({ on: { activeChange: ({ pathname: changedPathname, mode }) => {
+		if (changedPathname === routePathname) setIsActive(mode === "visible");
+	} } });
+	return isActive;
+}
+//#endregion
+export { useRouteCacheActive };

package/dist/hooks/use-route-cache-activity.cjs

@@ -0,0 +1,12 @@
+const require_use_event_listener = require("./use-event-listener.cjs");
+let _tanstack_react_router = require("@tanstack/react-router");
+//#region src/hooks/use-route-cache-activity.ts
+function useRouteCacheActivity(fn) {
+	const routePathname = (0, _tanstack_react_router.useLocation)({ select: (location) => location.pathname });
+	require_use_event_listener.useEventListener({ on: { activeChange: ({ pathname, mode, callback }) => {
+		if (pathname === routePathname) fn(mode === "visible");
+		callback?.();
+	} } });
+}
+//#endregion
+exports.useRouteCacheActivity = useRouteCacheActivity;

package/dist/hooks/use-route-cache-activity.js

@@ -0,0 +1,12 @@
+import { useEventListener } from "./use-event-listener.js";
+import { useLocation } from "@tanstack/react-router";
+//#region src/hooks/use-route-cache-activity.ts
+function useRouteCacheActivity(fn) {
+	const routePathname = useLocation({ select: (location) => location.pathname });
+	useEventListener({ on: { activeChange: ({ pathname, mode, callback }) => {
+		if (pathname === routePathname) fn(mode === "visible");
+		callback?.();
+	} } });
+}
+//#endregion
+export { useRouteCacheActivity };