Open History to see the last commit
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})