Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

interaction.ts

342 lines8.7 KB

1import {
2 hydrateIdAttribute,
3 hydrateInteractionEventsAttribute,
4 hydrateWhenAttribute,
5} from './constants'
6import {
7 clearResolvedGateIdsInMarker,
8 getMarkerGate,
9 resolveHydrationMarker,
10} from './runtime'
11import type {
12 HydrationInteractionEvents,
13 HydrationPrefetchStrategy,
14 HydrationRuntimeContext,
15} from './types'
16​
17export type InteractionHydrationOptions = {
18 events?: HydrationInteractionEvents
20​
21const hydrateIdSelector = `[${hydrateIdAttribute}]`
22​
23type PendingReplayEvent = {
24 marker: Element
25 targetPath: Array<number>
26 type: string
27 event: Event
29​
30const defaultInteractionEvents = [
31 'pointerenter',
32 'focusin',
33 'pointerdown',
34 'click',
35] as const
36const supportedInteractionEvents = [
37 'auxclick',
38 'click',
39 'contextmenu',
40 'dblclick',
41 'focusin',
42 'keydown',
43 'keyup',
44 'mousedown',
45 'mouseenter',
46 'mouseover',
47 'mouseup',
48 'pointerdown',
49 'pointerenter',
50 'pointerover',
51 'pointerup',
52] as const
53const interactionType = 'interaction'
54const dynamicType = 'dynamic'
55const interactionHydrateSelector = `[${hydrateWhenAttribute}="${interactionType}"]`
56const delegatedHydrateSelector = `${interactionHydrateSelector},[${hydrateWhenAttribute}="${dynamicType}"]`
57const replayEventsByGateId = /* @__PURE__ */ new Map<
58 string,
59 Array<PendingReplayEvent>
60>()
61​
62function getIntentListenerEvents(
63 marker: Element,
64 events: ReadonlyArray<string>,
65) {
66 const listenerEvents = new Set(events)
67​
68 marker.querySelectorAll(delegatedHydrateSelector).forEach((childMarker) => {
69 if (childMarker.getAttribute(hydrateWhenAttribute) === dynamicType) {
70 supportedInteractionEvents.forEach((eventName) => {
71 listenerEvents.add(eventName)
72 })
73 return
74 }
75​
76 const attr = childMarker.getAttribute(hydrateInteractionEventsAttribute)
77 for (const eventName of attr === null
78 ? defaultInteractionEvents
79 : attr.split(/\s+/).filter(Boolean)) {
80 listenerEvents.add(eventName)
81 }
82 })
83​
84 return [...listenerEvents]
86​
87function queueHydrationReplayEvent(marker: Element, event: Event) {
88 if (!event.bubbles) return
89​
90 const id = marker.getAttribute(hydrateIdAttribute)
91 const when = marker.getAttribute(hydrateWhenAttribute)
92 if (!id || !when || when === 'never') return
93​
94 const target = event.target
95 if (!target) return
96​
97 const gate = getMarkerGate(marker)
98 if (gate?.resolved) return
99​
100 event.preventDefault()
101 event.stopPropagation()
102 event.stopImmediatePropagation()
103​
104 let targetPath: Array<number> = []
105 if (target instanceof Node && marker.contains(target)) {
106 let node: Element | null =
107 target instanceof Element ? target : target.parentElement
108​
109 while (node && node !== marker) {
110 const parent = node.parentElement
111 if (!parent) {
112 targetPath = []
113 break
114 }
115 targetPath.push(Array.prototype.indexOf.call(parent.children, node))
116 node = parent
117 }
118 targetPath.reverse()
119 }
120​
121 const pendingEvents = replayEventsByGateId.get(id) ?? []
122 pendingEvents.push({
123 marker,
124 targetPath,
125 type: event.type,
126 event,
127 })
128 replayEventsByGateId.set(id, pendingEvents)
130​
131if (typeof document !== 'undefined') {
132 const onIntent = (event: Event) => {
133 const target = event.target
134 if (!(target instanceof Element)) return
135​
136 let marker: Element | null = target.closest(hydrateIdSelector)
137 const markers: Array<Element> = []
138 let shouldHandle = false
139​
140 while (marker) {
141 markers.push(marker)
142​
143 const when = marker.getAttribute(hydrateWhenAttribute)
144 if (when === dynamicType) {
145 shouldHandle ||= event.type === 'click'
146 } else if (when === interactionType) {
147 const attr = marker.getAttribute(hydrateInteractionEventsAttribute)
148 const events: ReadonlyArray<string> =
149 attr === null
150 ? defaultInteractionEvents
151 : attr.split(/\s+/).filter(Boolean)
152 shouldHandle ||= events.includes(event.type)
153 }
154​
155 marker = marker.parentElement?.closest(hydrateIdSelector) ?? null
156 }
157​
158 if (!shouldHandle) return
159​
160 markers.reverse()
161 if (markers.every((marker) => getMarkerGate(marker))) return
162​
163 markers.forEach((marker) => {
164 queueHydrationReplayEvent(marker, event)
165 resolveHydrationMarker(marker)
166 })
167 }
168​
169 supportedInteractionEvents.forEach((eventName) => {
170 document.addEventListener(eventName, onIntent, true)
171 })
173​
174function listenForIntent(
175 element: Element,
176 events: ReadonlyArray<string>,
177 context: HydrationRuntimeContext,
178) {
179 const onIntent = (event: Event) => {
180 const target = event.target
181 let marker: Element | null
182 if (target instanceof Element) {
183 const closestMarker = target.closest(hydrateIdSelector)
184 marker =
185 closestMarker && element.contains(closestMarker)
186 ? closestMarker
187 : element
188 } else {
189 marker = element
190 }
191​
192 const markers: Array<Element> = []
193 while (marker) {
194 if (marker.hasAttribute(hydrateIdAttribute)) {
195 markers.push(marker)
196 }
197 if (marker === element) break
198 marker = marker.parentElement
199 }
200​
201 if (!markers.includes(element)) {
202 markers.push(element)
203 }
204​
205 markers.reverse()
206​
207 if (
208 context.delegated &&
209 !markers.some(
210 (marker) =>
211 marker.getAttribute(hydrateWhenAttribute) === interactionType ||
212 marker.getAttribute(hydrateWhenAttribute) === dynamicType,
213 )
214 ) {
215 return
216 }
217​
218 markers.forEach((marker) => {
219 queueHydrationReplayEvent(marker, event)
220 resolveHydrationMarker(marker)
221 })
222 }
223 let disposed = false
224​
225 events.forEach((eventName) => {
226 element.addEventListener(eventName, onIntent, true)
227 })
228​
229 return () => {
230 if (disposed) return
231 disposed = true
232 events.forEach((eventName) => {
233 element.removeEventListener(eventName, onIntent, true)
234 })
235 }
237​
238export function listenForDelegatedHydrationIntent(
239 element: Element,
240 context: HydrationRuntimeContext,
241) {
242 const listenerEvents = getIntentListenerEvents(element, [])
243 if (!listenerEvents.length) return
244​
245 const cleanupIntent = listenForIntent(element, listenerEvents, {
246 ...context,
247 delegated: true,
248 })
249 return () => {
250 cleanupIntent()
251 clearResolvedGateIdsInMarker(element)
252 }
254​
255/* @__NO_SIDE_EFFECTS__ */
256export function interaction(
257 options: InteractionHydrationOptions = {},
258): HydrationPrefetchStrategy<typeof interactionType> {
259 let events: ReadonlyArray<string> = defaultInteractionEvents
260 if (options.events !== undefined) {
261 const eventList: ReadonlyArray<string> =
262 typeof options.events === 'string' ? [options.events] : options.events
263 const normalizedEvents: Array<string> = []
264 const seen = new Set<string>()
265​
266 for (const eventName of eventList) {
267 if (!eventName || seen.has(eventName)) continue
268 seen.add(eventName)
269 normalizedEvents.push(eventName)
270 }
271​
272 events = normalizedEvents
273 }
274​
275 const eventKey = events.join(' ')
276​
277 return {
278 _t: interactionType,
279 _s: (context) => {
280 const element = context.element
281 if (!element) return
282 const prefetch = context.prefetch
283 if (prefetch) {
284 if (!events.length) return
285 let disposed = false
286​
287 events.forEach((eventName) => {
288 element.addEventListener(eventName, prefetch, true)
289 })
290​
291 return () => {
292 if (disposed) return
293 disposed = true
294 events.forEach((eventName) => {
295 element.removeEventListener(eventName, prefetch, true)
296 })
297 }
298 }
299​
300 const listenerEvents = getIntentListenerEvents(element, events)
301 const cleanupIntent = listenerEvents.length
302 ? listenForIntent(element, listenerEvents, context)
303 : undefined
304 return () => {
305 cleanupIntent?.()
306 clearResolvedGateIdsInMarker(element)
307 }
308 },
309 _o: (id) => {
310 globalThis.requestAnimationFrame(() => {
311 const pendingEvents = replayEventsByGateId.get(id)
312 if (!pendingEvents?.length) return
313​
314 replayEventsByGateId.delete(id)
315​
316 for (const pendingEvent of pendingEvents) {
317 let replayTarget: Element | null = pendingEvent.marker
318 for (const index of pendingEvent.targetPath) {
319 replayTarget = replayTarget.children[index] ?? null
320 if (!replayTarget) break
321 }
322​
323 const event = pendingEvent.event
324 replayTarget ??= pendingEvent.marker
325 replayTarget.dispatchEvent(
326 event instanceof MouseEvent
327 ? new MouseEvent(event.type, event)
328 : event instanceof FocusEvent
329 ? new FocusEvent(event.type, event)
330 : new Event(event.type, event),
331 )
332 }
333 })
334 },
335 _a: () =>
336 options.events === undefined
337 ? undefined
338 : {
339 [hydrateInteractionEventsAttribute]: eventKey,
340 },
341 }