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

useLoaderData.test-d.tsx

379 lines9.2 KB

1import { expectTypeOf, test } from 'vitest'
2import {
3 createRootRoute,
4 createRoute,
5 createRouter,
6 useLoaderData,
7} from '../src'
8import type { Accessor } from 'solid-js'
9​
10test('when there is no loaders', () => {
11 const rootRoute = createRootRoute()
12​
13 const indexRoute = createRoute({
14 getParentRoute: () => rootRoute,
15 path: '/',
16 })
17​
18 const invoicesRoute = createRoute({
19 getParentRoute: () => rootRoute,
20 path: 'invoices',
21 })
22​
23 const invoicesIndexRoute = createRoute({
24 getParentRoute: () => invoicesRoute,
25 path: '/',
26 })
27​
28 const routeTree = rootRoute.addChildren([
29 invoicesRoute.addChildren([invoicesIndexRoute]),
30 indexRoute,
31 ])
32​
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(useLoaderData<DefaultRouter, '/'>).returns.toEqualTypeOf<
61 Accessor<undefined>
62 >()
63​
64 expectTypeOf(useLoaderData<DefaultRouter, '/', false>({ strict: false }))
65 .toEqualTypeOf<Accessor<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 const defaultRouter = createRouter({
98 routeTree,
99 context: { userId: 'userId' },
100 })
101​
102 type DefaultRouter = typeof defaultRouter
103​
104 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
105 Accessor<{ data: Array<string> }>
106 >()
107​
108 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
109 Accessor<{ data: Array<string> }>
110 >()
111​
112 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
113 .parameter(0)
114 .toHaveProperty('select')
115 .returns.toEqualTypeOf<unknown>()
116​
117 expectTypeOf(
118 useLoaderData<DefaultRouter, '/invoices', false>,
119 ).returns.toEqualTypeOf<Accessor<{ data?: Array<string> } | undefined>>()
120​
121 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
122 .parameter(0)
123 .toHaveProperty('select')
124 .returns.toEqualTypeOf<unknown>()
125​
126 expectTypeOf(
127 useLoaderData<DefaultRouter, '/invoices', false, number>,
128 ).returns.toEqualTypeOf<Accessor<number>>()
129})
130​
131test('when there is one loader that is async', () => {
132 const rootRoute = createRootRoute()
133​
134 const indexRoute = createRoute({
135 getParentRoute: () => rootRoute,
136 path: '/',
137 })
138​
139 const invoicesRoute = createRoute({
140 getParentRoute: () => rootRoute,
141 path: 'invoices',
142 loader: () => Promise.resolve({ data: ['element1', 'element2'] }),
143 })
144​
145 const invoicesIndexRoute = createRoute({
146 getParentRoute: () => invoicesRoute,
147 path: '/',
148 })
149​
150 const invoiceRoute = createRoute({
151 getParentRoute: () => invoicesRoute,
152 path: '$invoiceId',
153 })
154​
155 const routeTree = rootRoute.addChildren([
156 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
157 indexRoute,
158 ])
159​
160 const defaultRouter = createRouter({
161 routeTree,
162 context: { userId: 'userId' },
163 })
164​
165 type DefaultRouter = typeof defaultRouter
166​
167 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
168 Accessor<{ data: Array<string> }>
169 >()
170​
171 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
172 Accessor<{ data: Array<string> }>
173 >()
174​
175 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
176 .parameter(0)
177 .toHaveProperty('select')
178 .returns.toEqualTypeOf<unknown>()
179​
180 expectTypeOf(
181 useLoaderData<DefaultRouter, '/invoices', false>,
182 ).returns.toEqualTypeOf<Accessor<{ data?: Array<string> } | undefined>>()
183​
184 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
185 .parameter(0)
186 .toHaveProperty('select')
187 .returns.toEqualTypeOf<unknown>()
188​
189 expectTypeOf(
190 useLoaderData<DefaultRouter, '/invoices', false, number>,
191 ).returns.toEqualTypeOf<Accessor<number>>()
192})
193​
194test('when there are multiple loaders', () => {
195 const rootRoute = createRootRoute()
196​
197 const indexRoute = createRoute({
198 getParentRoute: () => rootRoute,
199 path: '/',
200 })
201​
202 const invoicesRoute = createRoute({
203 getParentRoute: () => rootRoute,
204 path: 'invoices',
205 loader: () => ({ data: ['invoice1', 'invoice2'] }) as const,
206 })
207​
208 const invoicesIndexRoute = createRoute({
209 getParentRoute: () => invoicesRoute,
210 path: '/',
211 })
212​
213 const postsRoute = createRoute({
214 getParentRoute: () => rootRoute,
215 path: 'posts',
216 loader: () => ({ data: ['post1', 'post2'] }) as const,
217 })
218​
219 const routeTree = rootRoute.addChildren([
220 invoicesRoute.addChildren([invoicesIndexRoute]),
221 postsRoute,
222 indexRoute,
223 ])
224​
225 const defaultRouter = createRouter({
226 routeTree,
227 })
228​
229 type DefaultRouter = typeof defaultRouter
230​
231 expectTypeOf(useLoaderData<DefaultRouter, '/'>).returns.toEqualTypeOf<
232 Accessor<undefined>
233 >()
234​
235 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
236 Accessor<{
237 readonly data: readonly ['invoice1', 'invoice2']
238 }>
239 >()
240​
241 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
242 .parameter(0)
243 .toHaveProperty('select')
244 .returns.toEqualTypeOf<unknown>()
245​
246 expectTypeOf(
247 useLoaderData<DefaultRouter, '/invoices', false>,
248 ).returns.toEqualTypeOf<
249 Accessor<
250 | {
251 data?:
252 | readonly ['invoice1', 'invoice2']
253 | readonly ['post1', 'post2']
254 | undefined
255 }
256 | undefined
257 >
258 >()
259​
260 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
261 .parameter(0)
262 .toHaveProperty('select')
263 .returns.toEqualTypeOf<unknown>()
264​
265 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
266 .parameter(0)
267 .toHaveProperty('select')
268 .parameter(0)
269 .toEqualTypeOf<
270 | {
271 data?:
272 | readonly ['invoice1', 'invoice2']
273 | readonly ['post1', 'post2']
274 | undefined
275 }
276 | undefined
277 >()
278​
279 expectTypeOf(
280 useLoaderData<DefaultRouter, '/invoices', true, { func: () => void }>,
281 )
282 .parameter(0)
283 .exclude<undefined>()
284 .toHaveProperty('select')
285 .exclude<undefined>()
286 .returns.toEqualTypeOf<{ func: () => void }>()
287})
288​
289test('when there are multiple loaders of objects and primtives', () => {
290 const rootRoute = createRootRoute()
291​
292 const indexRoute = createRoute({
293 getParentRoute: () => rootRoute,
294 path: '/',
295 })
296​
297 const invoicesRoute = createRoute({
298 getParentRoute: () => rootRoute,
299 path: 'invoices',
300 loader: () => ['invoice1', 'invoice2'] as const,
301 })
302​
303 const invoicesIndexRoute = createRoute({
304 getParentRoute: () => invoicesRoute,
305 path: '/',
306 loader: () => ({ invoice: { id: 1 } }) as const,
307 })
308​
309 const postsRoute = createRoute({
310 getParentRoute: () => rootRoute,
311 path: 'posts',
312 loader: () => ['post1', 'post2'] as const,
313 })
314​
315 const routeTree = rootRoute.addChildren([
316 invoicesRoute.addChildren([invoicesIndexRoute]),
317 indexRoute,
318 postsRoute,
319 ])
320​
321 const defaultRouter = createRouter({
322 routeTree,
323 })
324​
325 type DefaultRouter = typeof defaultRouter
326​
327 expectTypeOf(useLoaderData<DefaultRouter, '/'>).returns.toEqualTypeOf<
328 Accessor<undefined>
329 >()
330​
331 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
332 Accessor<readonly ['invoice1', 'invoice2']>
333 >()
334​
335 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
336 .parameter(0)
337 .toHaveProperty('select')
338 .returns.toEqualTypeOf<unknown>()
339​
340 expectTypeOf(useLoaderData<DefaultRouter, '/invoices'>)
341 .parameter(0)
342 .toHaveProperty('select')
343 .parameter(0)
344 .toEqualTypeOf<readonly ['invoice1', 'invoice2']>()
345​
346 expectTypeOf(
347 useLoaderData<DefaultRouter, '/invoices', false>,
348 ).returns.toEqualTypeOf<
349 Accessor<
350 | readonly ['invoice1', 'invoice2']
351 | readonly ['post1', 'post2']
352 | {
353 invoice?:
354 | {
355 readonly id: 1
356 }
357 | undefined
358 }
359 | undefined
360 >
361 >()
362​
363 expectTypeOf(useLoaderData<DefaultRouter, '/invoices', false>)
364 .parameter(0)
365 .toHaveProperty('select')
366 .parameter(0)
367 .toEqualTypeOf<
368 | readonly ['invoice1', 'invoice2']
369 | readonly ['post1', 'post2']
370 | {
371 invoice?:
372 | {
373 readonly id: 1
374 }
375 | undefined
376 }
377 | undefined
378 >()
379})