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