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

useLoaderData.test-d.tsx

441 lines10.7 KB

1import { expectTypeOf, test } from 'vitest'
2import {
3 createRootRoute,
4 createRoute,
5 createRouter,
6 useLoaderData,
7} from '../src'
8​
9test('when there is no loaders', () => {
10 const rootRoute = createRootRoute()
11​
12 const indexRoute = createRoute({
13 getParentRoute: () => rootRoute,
14 path: '/',
15 })
16​
17 const invoicesRoute = createRoute({
18 getParentRoute: () => rootRoute,
19 path: 'invoices',
20 })
21​
22 const invoicesIndexRoute = createRoute({
23 getParentRoute: () => invoicesRoute,
24 path: '/',
25 })
26​
27 const routeTree = rootRoute.addChildren([
28 invoicesRoute.addChildren([invoicesIndexRoute]),
29 indexRoute,
30 ])
31​
32 // eslint-disable-next-line unused-imports/no-unused-vars
33 const defaultRouter = createRouter({
34 routeTree,
35 })
36​
37 type DefaultRouter = typeof defaultRouter
38​
39 expectTypeOf(useLoaderData<DefaultRouter>)
40 .parameter(0)
41 .toHaveProperty('from')
42 .toEqualTypeOf<'/invoices' | '__root__' | '/invoices/' | '/'>()
43​
44 expectTypeOf(useLoaderData<DefaultRouter>)
45 .parameter(0)
46 .toHaveProperty('strict')
47 .toEqualTypeOf<true | undefined>()
48​
49 expectTypeOf(useLoaderData<DefaultRouter, '/'>)
50 .parameter(0)
51 .toHaveProperty('select')
52 .parameter(0)
53 .toMatchTypeOf<undefined>()
54​
55 expectTypeOf(useLoaderData<DefaultRouter, '/'>)
56 .parameter(0)
57 .toHaveProperty('select')
58 .returns.toEqualTypeOf<unknown>()
59​
60 expectTypeOf(
61 useLoaderData<DefaultRouter, '/'>,
62 ).returns.toEqualTypeOf<undefined>()
63​
64 expectTypeOf(useLoaderData<DefaultRouter, '/', false>({ strict: false }))
65 .toEqualTypeOf<undefined>
66})
67​
68test('when there is one loader', () => {
69 const rootRoute = createRootRoute()
70​
71 const indexRoute = createRoute({
72 getParentRoute: () => rootRoute,
73 path: '/',
74 })
75​
76 const invoicesRoute = createRoute({
77 getParentRoute: () => rootRoute,
78 path: 'invoices',
79 loader: () => ({ data: ['element1', 'element2'] }),
80 })
81​
82 const invoicesIndexRoute = createRoute({
83 getParentRoute: () => invoicesRoute,
84 path: '/',
85 })
86​
87 const invoiceRoute = createRoute({
88 getParentRoute: () => invoicesRoute,
89 path: '$invoiceId',
90 })
91​
92 const routeTree = rootRoute.addChildren([
93 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
94 indexRoute,
95 ])
96​
97 // eslint-disable-next-line unused-imports/no-unused-vars
98 const defaultRouter = createRouter({
99 routeTree,
100 context: { userId: 'userId' },
101 })
102​
103 type DefaultRouter = typeof defaultRouter
104​
105 expectTypeOf(
106 useLoaderData<DefaultRouter, '/invoices'>,
107 ).returns.toEqualTypeOf<{ data: Array<string> }>()
108​
109 expectTypeOf(
110 useLoaderData<DefaultRouter, '/invoices'>,
111 ).returns.toEqualTypeOf<{ data: Array<string> }>()
112​
113 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
114 .parameter(0)
115 .toHaveProperty('select')
116 .returns.toEqualTypeOf<unknown>()
117​
118 expectTypeOf(
119 useLoaderData<DefaultRouter, '/invoices', false>,
120 ).returns.toEqualTypeOf<{ data?: Array<string> } | undefined>()
121​
122 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
123 .parameter(0)
124 .toHaveProperty('select')
125 .returns.toEqualTypeOf<unknown>()
126​
127 expectTypeOf(
128 useLoaderData<DefaultRouter, '/invoices', false, number>,
129 ).returns.toEqualTypeOf<number>()
130})
131​
132test('when there is one loader that is async', () => {
133 const rootRoute = createRootRoute()
134​
135 const indexRoute = createRoute({
136 getParentRoute: () => rootRoute,
137 path: '/',
138 })
139​
140 const invoicesRoute = createRoute({
141 getParentRoute: () => rootRoute,
142 path: 'invoices',
143 loader: () => Promise.resolve({ data: ['element1', 'element2'] }),
144 })
145​
146 const invoicesIndexRoute = createRoute({
147 getParentRoute: () => invoicesRoute,
148 path: '/',
149 })
150​
151 const invoiceRoute = createRoute({
152 getParentRoute: () => invoicesRoute,
153 path: '$invoiceId',
154 })
155​
156 const routeTree = rootRoute.addChildren([
157 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
158 indexRoute,
159 ])
160​
161 // eslint-disable-next-line unused-imports/no-unused-vars
162 const defaultRouter = createRouter({
163 routeTree,
164 context: { userId: 'userId' },
165 })
166​
167 type DefaultRouter = typeof defaultRouter
168​
169 expectTypeOf(
170 useLoaderData<DefaultRouter, '/invoices'>,
171 ).returns.toEqualTypeOf<{ data: Array<string> }>()
172​
173 expectTypeOf(
174 useLoaderData<DefaultRouter, '/invoices'>,
175 ).returns.toEqualTypeOf<{ data: Array<string> }>()
176​
177 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
178 .parameter(0)
179 .toHaveProperty('select')
180 .returns.toEqualTypeOf<unknown>()
181​
182 expectTypeOf(
183 useLoaderData<DefaultRouter, '/invoices', false>,
184 ).returns.toEqualTypeOf<{ data?: Array<string> } | undefined>()
185​
186 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
187 .parameter(0)
188 .toHaveProperty('select')
189 .returns.toEqualTypeOf<unknown>()
190​
191 expectTypeOf(
192 useLoaderData<DefaultRouter, '/invoices', false, number>,
193 ).returns.toEqualTypeOf<number>()
194})
195​
196test('when there are multiple loaders', () => {
197 const rootRoute = createRootRoute()
198​
199 const indexRoute = createRoute({
200 getParentRoute: () => rootRoute,
201 path: '/',
202 })
203​
204 const invoicesRoute = createRoute({
205 getParentRoute: () => rootRoute,
206 path: 'invoices',
207 loader: () => ({ data: ['invoice1', 'invoice2'] }) as const,
208 })
209​
210 const invoicesIndexRoute = createRoute({
211 getParentRoute: () => invoicesRoute,
212 path: '/',
213 })
214​
215 const postsRoute = createRoute({
216 getParentRoute: () => rootRoute,
217 path: 'posts',
218 loader: () => ({ data: ['post1', 'post2'] }) as const,
219 })
220​
221 const routeTree = rootRoute.addChildren([
222 invoicesRoute.addChildren([invoicesIndexRoute]),
223 postsRoute,
224 indexRoute,
225 ])
226​
227 // eslint-disable-next-line unused-imports/no-unused-vars
228 const defaultRouter = createRouter({
229 routeTree,
230 })
231​
232 type DefaultRouter = typeof defaultRouter
233​
234 expectTypeOf(
235 useLoaderData<DefaultRouter, '/'>,
236 ).returns.toEqualTypeOf<undefined>()
237​
238 expectTypeOf(
239 useLoaderData<DefaultRouter, '/invoices'>,
240 ).returns.toEqualTypeOf<{
241 readonly data: readonly ['invoice1', 'invoice2']
242 }>()
243​
244 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
245 .parameter(0)
246 .toHaveProperty('select')
247 .returns.toEqualTypeOf<unknown>()
248​
249 expectTypeOf(
250 useLoaderData<DefaultRouter, '/invoices', false>,
251 ).returns.toEqualTypeOf<
252 | {
253 data?:
254 | readonly ['invoice1', 'invoice2']
255 | readonly ['post1', 'post2']
256 | undefined
257 }
258 | undefined
259 >()
260​
261 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
262 .parameter(0)
263 .toHaveProperty('select')
264 .returns.toEqualTypeOf<unknown>()
265​
266 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
267 .parameter(0)
268 .toHaveProperty('select')
269 .parameter(0)
270 .toEqualTypeOf<
271 | {
272 data?:
273 | readonly ['invoice1', 'invoice2']
274 | readonly ['post1', 'post2']
275 | undefined
276 }
277 | undefined
278 >()
279​
280 expectTypeOf(
281 useLoaderData<DefaultRouter, '/invoices', true, { func: () => void }>,
282 )
283 .parameter(0)
284 .exclude<undefined>()
285 .toHaveProperty('select')
286 .exclude<undefined>()
287 .returns.toEqualTypeOf<{ func: () => void }>()
288​
289 expectTypeOf(
290 useLoaderData<DefaultRouter, '/invoices', true, { func: () => void }>,
291 )
292 .parameter(0)
293 .exclude<undefined>()
294 .toHaveProperty('structuralSharing')
295 .toEqualTypeOf<false | undefined>()
296​
297 expectTypeOf(
298 useLoaderData<DefaultRouter, '/invoices', true, { func: () => void }, true>,
299 )
300 .parameter(0)
301 .exclude<undefined>()
302 .toHaveProperty('select')
303 .exclude<undefined>()
304 .returns.toEqualTypeOf<{ func: 'Function is not serializable' }>()
305​
306 expectTypeOf(
307 useLoaderData<DefaultRouter, '/invoices', true, { func: () => void }, true>,
308 )
309 .parameter(0)
310 .exclude<undefined>()
311 .toHaveProperty('structuralSharing')
312 .toEqualTypeOf<false | undefined>()
313​
314 // eslint-disable-next-line unused-imports/no-unused-vars
315 const routerWithStructuralSharing = createRouter({
316 routeTree,
317 defaultStructuralSharing: true,
318 })
319​
320 expectTypeOf(
321 useLoaderData<
322 typeof routerWithStructuralSharing,
323 '/invoices',
324 true,
325 { func: () => void },
326 true
327 >,
328 )
329 .parameter(0)
330 .exclude<undefined>()
331 .toHaveProperty('select')
332 .exclude<undefined>()
333 .returns.toEqualTypeOf<{
334 func: 'Function is not serializable'
335 }>()
336​
337 expectTypeOf(
338 useLoaderData<
339 typeof routerWithStructuralSharing,
340 '/invoices',
341 true,
342 { func: () => void },
343 true
344 >,
345 )
346 .parameter(0)
347 .exclude<undefined>()
348 .toHaveProperty('structuralSharing')
349 .toEqualTypeOf<false>()
350})
351​
352test('when there are multiple loaders of objects and primtives', () => {
353 const rootRoute = createRootRoute()
354​
355 const indexRoute = createRoute({
356 getParentRoute: () => rootRoute,
357 path: '/',
358 })
359​
360 const invoicesRoute = createRoute({
361 getParentRoute: () => rootRoute,
362 path: 'invoices',
363 loader: () => ['invoice1', 'invoice2'] as const,
364 })
365​
366 const invoicesIndexRoute = createRoute({
367 getParentRoute: () => invoicesRoute,
368 path: '/',
369 loader: () => ({ invoice: { id: 1 } }) as const,
370 })
371​
372 const postsRoute = createRoute({
373 getParentRoute: () => rootRoute,
374 path: 'posts',
375 loader: () => ['post1', 'post2'] as const,
376 })
377​
378 const routeTree = rootRoute.addChildren([
379 invoicesRoute.addChildren([invoicesIndexRoute]),
380 indexRoute,
381 postsRoute,
382 ])
383​
384 // eslint-disable-next-line unused-imports/no-unused-vars
385 const defaultRouter = createRouter({
386 routeTree,
387 })
388​
389 type DefaultRouter = typeof defaultRouter
390​
391 expectTypeOf(
392 useLoaderData<DefaultRouter, '/'>,
393 ).returns.toEqualTypeOf<undefined>()
394​
395 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
396 readonly ['invoice1', 'invoice2']
397 >()
398​
399 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
400 .parameter(0)
401 .toHaveProperty('select')
402 .returns.toEqualTypeOf<unknown>()
403​
404 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
405 .parameter(0)
406 .toHaveProperty('select')
407 .parameter(0)
408 .toEqualTypeOf<readonly ['invoice1', 'invoice2']>()
409​
410 expectTypeOf(
411 useLoaderData<DefaultRouter, '/invoices', false>,
412 ).returns.toEqualTypeOf<
413 | readonly ['invoice1', 'invoice2']
414 | readonly ['post1', 'post2']
415 | {
416 invoice?:
417 | {
418 readonly id: 1
419 }
420 | undefined
421 }
422 | undefined
423 >()
424​
425 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
426 .parameter(0)
427 .toHaveProperty('select')
428 .parameter(0)
429 .toEqualTypeOf<
430 | readonly ['invoice1', 'invoice2']
431 | readonly ['post1', 'post2']
432 | {
433 invoice?:
434 | {
435 readonly id: 1
436 }
437 | undefined
438 }
439 | undefined
440 >()
441})