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

runtime.ts

193 lines4.9 KB

1import { hydrateIdAttribute, hydrateWhenAttribute } from './constants'
2import type {
3 HydrationPrefetchStrategy,
4 HydrationPrefetchWaitReason,
5 HydrationRuntimeGate,
6 HydrationWhen,
7} from './types'
8​
9const hydrateIdSelector = `[${hydrateIdAttribute}]`
10​
11export type HydrationGateRecord = HydrationRuntimeGate & {
12 id: string
13 when: HydrationWhen
14 promise: Promise<void>
15 consumers: number
16 resolveListeners: Set<() => void>
18​
19const gateRegistry = /* @__PURE__ */ new Map<string, HydrationGateRecord>()
20const resolvedGateIds = /* @__PURE__ */ new Set<string>()
21const fallbackHtmlByGateId = /* @__PURE__ */ new Map<string, string>()
22​
23export function createResolvedGate(
24 id: string,
25 when: HydrationWhen,
26): HydrationGateRecord {
27 return {
28 id,
29 when,
30 promise: Promise.resolve(),
31 resolve: () => {},
32 resolved: true,
33 consumers: 0,
34 resolveListeners: new Set<() => void>(),
35 }
37​
38export function getOrCreateGate(
39 id: string,
40 when: HydrationWhen,
41): HydrationGateRecord {
42 const existing = gateRegistry.get(id)
43 if (existing?.when === when) {
44 existing.consumers++
45 return existing
46 }
47​
48 let resolvePromise!: () => void
49 const promise = new Promise<void>((resolve) => {
50 resolvePromise = resolve
51 })
52​
53 const gate: HydrationGateRecord = {
54 id,
55 promise,
56 resolved: false,
57 consumers: 1,
58 when,
59 resolveListeners: new Set(),
60 resolve: () => {
61 if (gate.resolved) return
62 gate.resolved = true
63 resolvePromise()
64 gate.resolveListeners.forEach((listener) => listener())
65 gate.resolveListeners.clear()
66 },
67 }
68​
69 gateRegistry.set(id, gate)
70 if (when !== 'never' && resolvedGateIds.has(id)) {
71 resolvedGateIds.delete(id)
72 gate.resolve()
73 }
74 return gate
76​
77export function releaseGate(gate: HydrationGateRecord) {
78 resolvedGateIds.delete(gate.id)
79 gate.consumers--
80 if (gate.consumers > 0) return
81 if (gateRegistry.get(gate.id) === gate) {
82 gateRegistry.delete(gate.id)
83 fallbackHtmlByGateId.delete(gate.id)
84 gate.resolveListeners.clear()
85 }
87​
88export function onGateResolve(gate: HydrationGateRecord, listener: () => void) {
89 if (gate.resolved) {
90 listener()
91 return () => {}
92 }
93​
94 gate.resolveListeners.add(listener)
95 return () => {
96 gate.resolveListeners.delete(listener)
97 }
99​
100export function runHydrationStrategyCleanup(cleanup: void | (() => void)) {
101 if (typeof cleanup === 'function') return cleanup
102 return undefined
104​
105export function waitForHydrationPrefetchStrategy(
106 strategy: HydrationPrefetchStrategy,
107 options: {
108 element: Element | null
109 signal: AbortSignal
110 onHydrate: (listener: () => void) => () => void
111 },
112): Promise<HydrationPrefetchWaitReason> {
113 if (options.signal.aborted) {
114 return Promise.resolve('abort')
115 }
116​
117 return new Promise((resolve) => {
118 let disposed = false
119 // The strategy may finish synchronously before returning its cleanup.
120 let cleanupStrategy: void | (() => void) = undefined
121 let cleanupHydrate = () => {}
122​
123 const finish = (reason: HydrationPrefetchWaitReason) => {
124 if (disposed) {
125 return
126 }
127 disposed = true
128 options.signal.removeEventListener('abort', onAbort)
129 cleanupHydrate()
130 runHydrationStrategyCleanup(cleanupStrategy)?.()
131 resolve(reason)
132 }
133​
134 const onAbort = () => finish('abort')
135​
136 options.signal.addEventListener('abort', onAbort, { once: true })
137 cleanupHydrate = options.onHydrate(() => finish('hydrate'))
138 cleanupStrategy = strategy._s?.({
139 element: options.element,
140 prefetch: () => finish('prefetch'),
141 })
142 // A synchronous finish must immediately run the cleanup just returned.
143 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
144 if (disposed) {
145 runHydrationStrategyCleanup(cleanupStrategy)?.()
146 }
147 })
149​
150export function getMarkerGate(marker: Element) {
151 const id = marker.getAttribute(hydrateIdAttribute)
152 return id ? gateRegistry.get(id) : undefined
154​
155export function resolveHydrationMarker(marker: Element) {
156 const id = marker.getAttribute(hydrateIdAttribute)
157 const when = marker.getAttribute(hydrateWhenAttribute)
158 if (!id || !when || when === 'never') {
159 return
160 }
161​
162 const gate = gateRegistry.get(id)
163 if (gate) {
164 if (gate.when !== 'never') gate.resolve()
165 return
166 }
167​
168 resolvedGateIds.add(id)
170​
171export function clearResolvedGateIdsInMarker(marker: Element) {
172 const ownId = marker.getAttribute(hydrateIdAttribute)
173 if (ownId) {
174 resolvedGateIds.delete(ownId)
175 }
176​
177 marker.querySelectorAll(hydrateIdSelector).forEach((childMarker) => {
178 const childId = childMarker.getAttribute(hydrateIdAttribute)
179 if (childId) {
180 resolvedGateIds.delete(childId)
181 }
182 })
184​
185export function saveFallbackHtml(id: string, element: Element) {
186 if (!fallbackHtmlByGateId.has(id)) {
187 fallbackHtmlByGateId.set(id, element.innerHTML)
188 }
190​
191export function getFallbackHtml(id: string) {
192 return fallbackHtmlByGateId.get(id)