diff --git a/packages/react-router/src/link.tsx b/packages/react-router/src/link.tsx index 3023a10288..04de96c965 100644 --- a/packages/react-router/src/link.tsx +++ b/packages/react-router/src/link.tsx @@ -20,7 +20,6 @@ import { useMatches } from './Matches' import type { AnyRouter, Constrain, - LinkCurrentTargetElement, LinkOptions, RegisteredRouter, RoutePaths, @@ -54,6 +53,7 @@ export function useLinkProps< to, preload: userPreload, preloadDelay: userPreloadDelay, + preloadIntentProximity: userPreloadIntentProximity, hashScrollIntoView, replace, startTransition, @@ -115,16 +115,29 @@ export function useLinkProps< const next = React.useMemo( () => router.buildLocation(_options as any), - // eslint-disable-next-line react-hooks/exhaustive-deps + [router, _options, currentSearch], ) - const preload = React.useMemo(() => { + const { preload, preloadIntentProximity } = React.useMemo(() => { if (_options.reloadDocument) { - return false + return { preload: false, preloadIntentProximity: 0 } } - return userPreload ?? router.options.defaultPreload - }, [router.options.defaultPreload, userPreload, _options.reloadDocument]) + return { + preload: userPreload ?? router.options.defaultPreload, + preloadIntentProximity: + userPreloadIntentProximity ?? + router.options.defaultPreloadIntentProximity ?? + 0, + } as const + }, [ + router.options.defaultPreload, + userPreload, + _options.reloadDocument, + router.options.defaultPreloadIntentProximity, + userPreloadIntentProximity, + ]) + const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0 @@ -179,22 +192,63 @@ export function useLinkProps< console.warn(err) console.warn(preloadWarning) }) + // NOTE: Use this to debug preloading! + // .then(() => { + // // @ts-expect-error + // innerRef.current.style.boxShadow = '0 0 10px 0 rgba(255, 0, 0, 0.5)' + // }) }, [_options, router]) + const timeoutIdRef = React.useRef | null>(null) + const hasPreloadedRef = React.useRef(false) + + const tryPreload = React.useCallback(() => { + if (hasPreloadedRef.current || timeoutIdRef.current) { + return + } + + timeoutIdRef.current = setTimeout(() => { + doPreload() + hasPreloadedRef.current = true + timeoutIdRef.current = null + }, preloadDelay) + }, [preloadDelay, doPreload]) + + const cancelPreload = React.useCallback(() => { + if (timeoutIdRef.current) { + clearTimeout(timeoutIdRef.current) + timeoutIdRef.current = null + } + }, []) + + const isIntersectingRef = React.useRef(false) + + const shouldUseIntersectionObserver = React.useMemo(() => { + return ( + !disabled && + (preload === 'viewport' || + (preload === 'intent' && preloadIntentProximity > 0)) + ) + }, [preload, preloadIntentProximity, disabled]) + const preloadViewportIoCallback = React.useCallback( (entry: IntersectionObserverEntry | undefined) => { - if (entry?.isIntersecting) { + isIntersectingRef.current = entry?.isIntersecting ?? false + + if (isIntersectingRef.current && preload === 'viewport') { doPreload() } }, - [doPreload], + [doPreload, preload], ) useIntersectionObserver( innerRef, preloadViewportIoCallback, { rootMargin: '100px' }, - { disabled: !!disabled || !(preload === 'viewport') }, + { + disabled: !shouldUseIntersectionObserver, + }, ) useLayoutEffect(() => { @@ -207,6 +261,112 @@ export function useLinkProps< } }, [disabled, doPreload, preload]) + const rectRef = React.useRef(null) + + useLayoutEffect(() => { + if ( + type === 'internal' && + preload === 'intent' && + preloadIntentProximity > 0 && + disabled && + !innerRef.current + ) { + return + } + + let lastMousePosition: { + x: number + y: number + } | null = null + + let frameId: number | null = null + + const handleMousePos = (pairs: Array<{ x: number; y: number }>) => { + if (!isIntersectingRef.current || frameId) return + + frameId = requestAnimationFrame(() => { + // If one of pairs is within the preloadIntentProximity + // stop the loop + pairs.some(({ x, y }, i) => { + if (!rectRef.current) return + + // Calculate the distance to the nearest edge of the bounding box + const dx = Math.max( + rectRef.current.left - x, + 0, + x - rectRef.current.right, + ) + const dy = Math.max( + rectRef.current.top - y, + 0, + y - rectRef.current.bottom, + ) + + const distance = Math.sqrt(dx * dx + dy * dy) + + if (distance <= preloadIntentProximity) { + tryPreload() + return true + } else { + return false + } + }) + + frameId = null + }) + } + + const handleScroll = () => { + if (!lastMousePosition) return + handleMousePos([{ x: lastMousePosition.x, y: lastMousePosition.y }]) + } + + const handlePointerMove = (e: PointerEvent) => { + lastMousePosition = { + x: e.clientX, + y: e.clientY, + } + if ((e as any).getPredictedEvents) { + const events = e.getPredictedEvents() + handleMousePos([ + { + x: e.clientX, + y: e.clientY, + }, + ...events.map((event) => ({ + x: event.clientX, + y: event.clientY, + })), + ]) + } + } + + document.addEventListener('pointermove', handlePointerMove) + document.addEventListener('scroll', handleScroll, { passive: true }) + + return () => { + document.removeEventListener('pointermove', handlePointerMove) + document.removeEventListener('scroll', handleScroll) + cancelPreload() + } + }, [ + disabled, + doPreload, + preload, + preloadDelay, + preloadIntentProximity, + cancelPreload, + innerRef, + tryPreload, + type, + ]) + + useRectCallback(innerRef, (rect) => { + rectRef.current = rect + }) + + const pointerDownRef = React.useRef(false) + if (type === 'external') { return { ...propsSafeToSpread, @@ -260,42 +420,36 @@ export function useLinkProps< } } + const onPointerDown = (e: PointerEvent) => { + pointerDownRef.current = true + } + + const onPointerUp = (e: PointerEvent) => { + pointerDownRef.current = false + } + // The click handler const handleFocus = (_: MouseEvent) => { - if (disabled) return + if (disabled || pointerDownRef.current) return if (preload) { doPreload() } } + const handleMouseEnter = () => { + if (preload === 'intent' && preloadIntentProximity <= 0) { + tryPreload() + } + } + + const handleMouseLeave = () => { + if (preload === 'intent' && preloadIntentProximity <= 0) { + cancelPreload() + } + } + const handleTouchStart = handleFocus - const handleEnter = (e: MouseEvent) => { - if (disabled) return - const eventTarget = (e.target || {}) as LinkCurrentTargetElement - - if (preload) { - if (eventTarget.preloadTimeout) { - return - } - - eventTarget.preloadTimeout = setTimeout(() => { - eventTarget.preloadTimeout = null - doPreload() - }, preloadDelay) - } - } - - const handleLeave = (e: MouseEvent) => { - if (disabled) return - const eventTarget = (e.target || {}) as LinkCurrentTargetElement - - if (eventTarget.preloadTimeout) { - clearTimeout(eventTarget.preloadTimeout) - eventTarget.preloadTimeout = null - } - } - const composeHandlers = (handlers: Array void)>) => (e: { persist?: () => void; defaultPrevented: boolean }) => { @@ -341,9 +495,11 @@ export function useLinkProps< ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'], onClick: composeHandlers([onClick, handleClick]), onFocus: composeHandlers([onFocus, handleFocus]), - onMouseEnter: composeHandlers([onMouseEnter, handleEnter]), - onMouseLeave: composeHandlers([onMouseLeave, handleLeave]), + onMouseEnter: composeHandlers([onMouseEnter, handleMouseEnter]), + onMouseLeave: composeHandlers([onMouseLeave, handleMouseLeave]), onTouchStart: composeHandlers([onTouchStart, handleTouchStart]), + onPointerDown: composeHandlers([onPointerDown]), + onPointerUp: composeHandlers([onPointerUp]), disabled: !!disabled, target, ...(Object.keys(resolvedStyle).length && { style: resolvedStyle }), @@ -549,3 +705,67 @@ export type LinkOptionsFn = < export const linkOptions: LinkOptionsFn<'a'> = (options) => { return options as any } + +export const useRectCallback = ( + ref: React.RefObject, + onSizeChange: (rect: Rect) => void, +) => { + const handleResize = React.useCallback(() => { + if (!ref.current) { + return + } + + // Update client rect + const newRect = getRect(ref.current) + onSizeChange(newRect) + }, [ref, onSizeChange]) + + useLayoutEffect(() => { + const element = ref.current + if (!element) { + return + } + + handleResize() + + if (typeof ResizeObserver === 'function') { + const resizeObserver = new ResizeObserver(() => handleResize()) + resizeObserver.observe(element) + + return () => { + resizeObserver.disconnect() + } + } else { + // Browser support, remove freely + window.addEventListener('resize', handleResize) + + return () => { + window.removeEventListener('resize', handleResize) + } + } + }, [ref, handleResize]) +} + +type Rect = { + bottom: number + height: number + left: number + right: number + top: number + width: number +} + +function getRect(element: Element | null): Rect { + if (!element) { + return { + bottom: 0, + height: 0, + left: 0, + right: 0, + top: 0, + width: 0, + } + } + + return element.getBoundingClientRect() +} diff --git a/packages/solid-router/src/link.tsx b/packages/solid-router/src/link.tsx index ca43fd2fa3..b0f2dddbcd 100644 --- a/packages/solid-router/src/link.tsx +++ b/packages/solid-router/src/link.tsx @@ -42,6 +42,8 @@ export function useLinkProps< const [isTransitioning, setIsTransitioning] = Solid.createSignal(false) let hasRenderFetched = false + const innerRef: Element | null = null + const [local, rest] = Solid.splitProps( Solid.mergeProps( { @@ -57,6 +59,7 @@ export function useLinkProps< 'to', 'preload', 'preloadDelay', + 'preloadIntentProximity', 'hashScrollIntoView', 'replace', 'startTransition', @@ -155,6 +158,21 @@ export function useLinkProps< } return local.preload ?? router.options.defaultPreload }) + + const preloadMemo: () => { preload: any; preloadIntentProximity: any } = + Solid.createMemo(() => { + if (_options().reloadDocument) { + return { preload: false, preloadIntentProximity: 0 } + } + return { + preload: local.preload ?? router.options.defaultPreload, + preloadIntentProximity: + local.preloadIntentProximity ?? + router.options.defaultPreloadIntentProximity ?? + 0, + } as const + }) + const preloadDelay = () => local.preloadDelay ?? router.options.defaultPreloadDelay ?? 0 @@ -175,11 +193,11 @@ export function useLinkProps< router.basepath, ).split('/') const nextPathSplit = removeTrailingSlash( - next()?.pathname, + next().pathname, router.basepath, - )?.split('/') + ).split('/') - const pathIsFuzzyEqual = nextPathSplit?.every( + const pathIsFuzzyEqual = nextPathSplit.every( (d, i) => d === currentPathSplit[i], ) if (!pathIsFuzzyEqual) { @@ -210,10 +228,44 @@ export function useLinkProps< console.warn(preloadWarning) }) + let timeoutIdRef: any = null + let hasPreloadedRef = false + + const tryPreload = () => { + if (hasPreloadedRef || timeoutIdRef) { + return + } + + timeoutIdRef = setTimeout(() => { + doPreload() + hasPreloadedRef = true + timeoutIdRef = null + }, preloadDelay()) + } + + const cancelPreload = () => { + if (timeoutIdRef) { + clearTimeout(timeoutIdRef) + timeoutIdRef = null + } + } + + let isIntersectingRef = false + + const shouldUseIntersectionObserver = Solid.createMemo(() => { + return ( + !local.disabled && + (preload() === 'viewport' || + (preload() === 'intent' && preloadMemo().preloadIntentProximity() > 0)) + ) + }) + const preloadViewportIoCallback = ( entry: IntersectionObserverEntry | undefined, ) => { - if (entry?.isIntersecting) { + isIntersectingRef = entry?.isIntersecting ?? false + + if (isIntersectingRef && preloadMemo().preload === 'viewport') { doPreload() } } @@ -224,7 +276,12 @@ export function useLinkProps< ref, preloadViewportIoCallback, { rootMargin: '100px' }, - { disabled: !!local.disabled || !(preload() === 'viewport') }, + { + disabled: + !shouldUseIntersectionObserver() || + !!local.disabled || + !(preload() === 'viewport'), + }, ) Solid.createEffect(() => { @@ -237,6 +294,95 @@ export function useLinkProps< } }) + let rectRef: Rect | null = null + + Solid.createEffect(() => { + if ( + type() === 'internal' && + preloadMemo().preload === 'intent' && + preloadMemo().preloadIntentProximity > 0 && + local.disabled && + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + !innerRef + ) { + return + } + + let lastMousePosition: { + x: number + y: number + } | null = null + + let frameId: number | null = null + + const handleMousePos = (pairs: Array<{ x: number; y: number }>) => { + if (!isIntersectingRef || frameId) return + + frameId = requestAnimationFrame(() => { + // If one of pairs is within the preloadIntentProximity + // stop the loop + pairs.some(({ x, y }, i) => { + if (!rectRef) return + + // Calculate the distance to the nearest edge of the bounding box + const dx = Math.max(rectRef.left - x, 0, x - rectRef.right) + const dy = Math.max(rectRef.top - y, 0, y - rectRef.bottom) + + const distance = Math.sqrt(dx * dx + dy * dy) + + if (distance <= preloadMemo().preloadIntentProximity) { + tryPreload() + return true + } else { + return false + } + }) + + frameId = null + }) + } + + const handleScroll = () => { + if (!lastMousePosition) return + handleMousePos([{ x: lastMousePosition.x, y: lastMousePosition.y }]) + } + + const handlePointerMove = (e: PointerEvent) => { + lastMousePosition = { + x: e.clientX, + y: e.clientY, + } + if ((e as any).getPredictedEvents) { + const events = e.getPredictedEvents() + handleMousePos([ + { + x: e.clientX, + y: e.clientY, + }, + ...events.map((event) => ({ + x: event.clientX, + y: event.clientY, + })), + ]) + } + } + + document.addEventListener('pointermove', handlePointerMove) + document.addEventListener('scroll', handleScroll, { passive: true }) + + return () => { + document.removeEventListener('pointermove', handlePointerMove) + document.removeEventListener('scroll', handleScroll) + cancelPreload() + } + }) + + useRectCallback(innerRef, (rect) => { + rectRef = rect + }) + + let pointerDownRef = false + if (type() === 'external') { return Solid.mergeProps( propsSafeToSpread, @@ -298,14 +444,40 @@ export function useLinkProps< } } + const onPointerDown = (e: PointerEvent) => { + pointerDownRef = true + } + + const onPointerUp = (e: PointerEvent) => { + pointerDownRef = false + } + // The click handler const handleFocus = (_: MouseEvent) => { - if (local.disabled) return + if (local.disabled || pointerDownRef) return if (preload()) { doPreload() } } + const handleMouseEnter = () => { + if ( + preloadMemo().preload === 'intent' && + preloadMemo().preloadIntentProximity <= 0 + ) { + tryPreload() + } + } + + const handleMouseLeave = () => { + if ( + preloadMemo().preload === 'intent' && + preloadMemo().preloadIntentProximity <= 0 + ) { + cancelPreload() + } + } + const handleTouchStart = handleFocus const handleEnter = (e: MouseEvent) => { @@ -386,13 +558,13 @@ export function useLinkProps< const href = Solid.createMemo(() => { const nextLocation = next() - const maskedLocation = nextLocation?.maskedLocation + const maskedLocation = nextLocation.maskedLocation return _options().disabled ? undefined : maskedLocation ? router.history.createHref(maskedLocation.href) - : router.history.createHref(nextLocation?.href) + : router.history.createHref(nextLocation.href) }) return Solid.mergeProps( @@ -405,14 +577,22 @@ export function useLinkProps< ref: mergeRefs(setRef, _options().ref), onClick: composeEventHandlers([local.onClick, handleClick]), onFocus: composeEventHandlers([local.onFocus, handleFocus]), - onMouseEnter: composeEventHandlers([local.onMouseEnter, handleEnter]), + onMouseEnter: composeEventHandlers([ + local.onMouseEnter, + handleMouseEnter, + ]), onMouseOver: composeEventHandlers([local.onMouseOver, handleEnter]), - onMouseLeave: composeEventHandlers([local.onMouseLeave, handleLeave]), + onMouseLeave: composeEventHandlers([ + local.onMouseLeave, + handleMouseLeave, + ]), onMouseOut: composeEventHandlers([local.onMouseOut, handleLeave]), onTouchStart: composeEventHandlers([ local.onTouchStart, handleTouchStart, ]), + onPointerDown: composeEventHandlers([onPointerDown]), + onPointerUp: composeEventHandlers([onPointerUp]), disabled: !!local.disabled, target: local.target, ...(Object.keys(resolvedStyle).length && { style: resolvedStyle }), @@ -595,3 +775,67 @@ export type LinkOptionsFn = < export const linkOptions: LinkOptionsFn<'a'> = (options) => { return options as any } + +export const useRectCallback = ( + ref: Element | null, + onSizeChange: (rect: Rect) => void, +) => { + const handleResize = () => { + if (!ref) { + return + } + + // Update client rect + const newRect = getRect(ref) + onSizeChange(newRect) + } + + Solid.createEffect(() => { + const element = ref + if (!element) { + return + } + + handleResize() + + if (typeof ResizeObserver === 'function') { + const resizeObserver = new ResizeObserver(() => handleResize()) + resizeObserver.observe(element) + + return () => { + resizeObserver.disconnect() + } + } else { + // Browser support, remove freely + window.addEventListener('resize', handleResize) + + return () => { + window.removeEventListener('resize', handleResize) + } + } + }, [ref, handleResize]) +} + +type Rect = { + bottom: number + height: number + left: number + right: number + top: number + width: number +} + +function getRect(element: Element | null): Rect { + if (!element) { + return { + bottom: 0, + height: 0, + left: 0, + right: 0, + top: 0, + width: 0, + } + } + + return element.getBoundingClientRect() +}