Open History to see the last commit
1import { describe, expectTypeOf, test } from 'vitest'
2import { createRootRoute, createRoute, createRouter, useSearch } from '../src'
3import type { Accessor } from 'solid-js'
4import type { SearchSchemaInput } from '../src'
5β
6describe('useSearch', () => {
7 test('when there are no search params', () => {
8 const rootRoute = createRootRoute()
9β
10 const indexRoute = createRoute({
11 getParentRoute: () => rootRoute,
12 path: '/',
13 })
14β
15 const invoicesRoute = createRoute({
16 getParentRoute: () => rootRoute,
17 path: 'invoices',
18 })
19β
20 const invoicesIndexRoute = createRoute({
21 getParentRoute: () => invoicesRoute,
22 path: '/',
23 })
24β
25 const invoiceRoute = createRoute({
26 getParentRoute: () => invoicesRoute,
27 path: '$invoiceId',
28 })
29β
30 const routeTree = rootRoute.addChildren([
31 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
32 indexRoute,
33 ])
34β
35 const defaultRouter = createRouter({
36 routeTree,
37 })
38β
39 type DefaultRouter = typeof defaultRouter
40β
41 expectTypeOf(useSearch<DefaultRouter>)
42 .parameter(0)
43 .toHaveProperty('from')
44 .toEqualTypeOf<
45 '/invoices' | '__root__' | '/invoices/$invoiceId' | '/invoices/' | '/'
46 >()
47β
48 expectTypeOf(useSearch<DefaultRouter>)
49 .parameter(0)
50 .toHaveProperty('strict')
51 .toEqualTypeOf<true | undefined>()
52β
53 expectTypeOf(useSearch<DefaultRouter, '/'>)
54 .parameter(0)
55 .toHaveProperty('select')
56 .parameter(0)
57 .toEqualTypeOf<{}>()
58β
59 expectTypeOf(useSearch<DefaultRouter, '/'>)
60 .parameter(0)
61 .toHaveProperty('select')
62 .returns.toEqualTypeOf<unknown>()
63β
64 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
65 Accessor<{}>
66 >()
67β
68 expectTypeOf(
69 useSearch<DefaultRouter, '/', false>({
70 strict: false,
71 }),
72 ).toEqualTypeOf<Accessor<{}>>()
73 })
74β
75 test('when there is one search params', () => {
76 const rootRoute = createRootRoute()
77β
78 const indexRoute = createRoute({
79 getParentRoute: () => rootRoute,
80 path: '/',
81 })
82β
83 const invoicesRoute = createRoute({
84 getParentRoute: () => rootRoute,
85 path: 'invoices',
86 validateSearch: () => ({ page: 0 }),
87 })
88β
89 const invoicesIndexRoute = createRoute({
90 getParentRoute: () => invoicesRoute,
91 path: '/',
92 })
93β
94 const invoiceRoute = createRoute({
95 getParentRoute: () => invoicesRoute,
96 path: '$invoiceId',
97 })
98β
99 const routeTree = rootRoute.addChildren([
100 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
101 indexRoute,
102 ])
103β
104 const defaultRouter = createRouter({
105 routeTree,
106 })
107β
108 type DefaultRouter = typeof defaultRouter
109β
110 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
111 Accessor<{}>
112 >()
113β
114 expectTypeOf(useSearch<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
115 Accessor<{
116 page: number
117 }>
118 >()
119β
120 expectTypeOf(useSearch<DefaultRouter, '/invoices'>)
121 .parameter(0)
122 .toHaveProperty('select')
123 .toEqualTypeOf<((search: { page: number }) => unknown) | undefined>()
124β
125 expectTypeOf(
126 useSearch<DefaultRouter, '/invoices', false>,
127 ).returns.toEqualTypeOf<Accessor<{ page?: number }>>()
128β
129 expectTypeOf(useSearch<DefaultRouter, '/invoices', false>)
130 .parameter(0)
131 .toHaveProperty('select')
132 .toEqualTypeOf<((search: { page?: number }) => unknown) | undefined>()
133β
134 expectTypeOf(
135 useSearch<
136 DefaultRouter,
137 '/invoices',
138 /* strict */ false,
139 /* shouldThrow */ true,
140 number
141 >,
142 ).returns.toEqualTypeOf<Accessor<number>>()
143β
144 expectTypeOf(
145 useSearch<
146 DefaultRouter,
147 '/invoices',
148 /* strict */ false,
149 /* shouldThrow */ true,
150 { func: () => void }
151 >,
152 )
153 .parameter(0)
154 .toHaveProperty('select')
155 .toEqualTypeOf<
156 ((search: { page?: number }) => { func: () => void }) | undefined
157 >()
158 })
159β
160 test('when there are multiple search params', () => {
161 const rootRoute = createRootRoute()
162β
163 const indexRoute = createRoute({
164 getParentRoute: () => rootRoute,
165 path: '/',
166 })
167β
168 const invoicesRoute = createRoute({
169 getParentRoute: () => rootRoute,
170 path: 'invoices',
171 validateSearch: () => ({ page: 0 }),
172 })
173β
174 const invoicesIndexRoute = createRoute({
175 getParentRoute: () => invoicesRoute,
176 path: '/',
177 })
178β
179 const invoiceRoute = createRoute({
180 getParentRoute: () => invoicesRoute,
181 path: '$invoiceId',
182 validateSearch: () => ({ detail: 'detail' }),
183 })
184β
185 const routeTree = rootRoute.addChildren([
186 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
187 indexRoute,
188 ])
189β
190 const defaultRouter = createRouter({
191 routeTree,
192 })
193β
194 type DefaultRouter = typeof defaultRouter
195β
196 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
197 Accessor<{}>
198 >()
199β
200 expectTypeOf(useSearch<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
201 Accessor<{
202 page: number
203 }>
204 >()
205β
206 expectTypeOf(useSearch<DefaultRouter, '/invoices'>)
207 .parameter(0)
208 .toHaveProperty('select')
209 .toEqualTypeOf<((search: { page: number }) => unknown) | undefined>()
210β
211 expectTypeOf(
212 useSearch<DefaultRouter, '/invoices', false>,
213 ).returns.toEqualTypeOf<Accessor<{ page?: number; detail?: string }>>()
214β
215 expectTypeOf(useSearch<DefaultRouter, '/invoices', false>)
216 .parameter(0)
217 .toHaveProperty('select')
218 .toEqualTypeOf<
219 ((search: { page?: number; detail?: string }) => unknown) | undefined
220 >()
221 })
222β
223 test('when there are overlapping search params', () => {
224 const rootRoute = createRootRoute()
225β
226 const indexRoute = createRoute({
227 getParentRoute: () => rootRoute,
228 path: '/',
229 })
230β
231 const invoicesRoute = createRoute({
232 getParentRoute: () => rootRoute,
233 path: 'invoices',
234 validateSearch: () => ({ page: 0 }),
235 })
236β
237 const invoicesIndexRoute = createRoute({
238 getParentRoute: () => invoicesRoute,
239 path: '/',
240 validateSearch: () => ({ detail: 50 }) as const,
241 })
242β
243 const invoiceRoute = createRoute({
244 getParentRoute: () => invoicesRoute,
245 path: '$invoiceId',
246 validateSearch: () => ({ detail: 'detail' }) as const,
247 })
248β
249 const routeTree = rootRoute.addChildren([
250 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
251 indexRoute,
252 ])
253β
254 const defaultRouter = createRouter({
255 routeTree,
256 })
257β
258 type DefaultRouter = typeof defaultRouter
259β
260 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
261 Accessor<{}>
262 >()
263β
264 expectTypeOf(useSearch<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
265 Accessor<{
266 page: number
267 }>
268 >()
269β
270 expectTypeOf(useSearch<DefaultRouter, '/invoices'>)
271 .parameter(0)
272 .toHaveProperty('select')
273 .toEqualTypeOf<((search: { page: number }) => unknown) | undefined>()
274β
275 expectTypeOf(
276 useSearch<DefaultRouter, '/invoices', false>,
277 ).returns.toEqualTypeOf<
278 Accessor<{ page?: number; detail?: 'detail' | 50 }>
279 >()
280β
281 expectTypeOf(useSearch<DefaultRouter, '/invoices', false>)
282 .parameter(0)
283 .toHaveProperty('select')
284 .toEqualTypeOf<
285 | ((search: { page?: number; detail?: 'detail' | 50 }) => unknown)
286 | undefined
287 >()
288 })
289β
290 test('when the root has no search params but the index route does', () => {
291 const rootRoute = createRootRoute()
292β
293 const indexRoute = createRoute({
294 getParentRoute: () => rootRoute,
295 path: '/',
296 validateSearch: () => ({ indexPage: 0 }),
297 })
298β
299 const invoicesRoute = createRoute({
300 getParentRoute: () => rootRoute,
301 path: 'invoices',
302 })
303β
304 const invoicesIndexRoute = createRoute({
305 getParentRoute: () => invoicesRoute,
306 path: '/',
307 })
308β
309 const invoiceRoute = createRoute({
310 getParentRoute: () => invoicesRoute,
311 path: '$invoiceId',
312 })
313β
314 const routeTree = rootRoute.addChildren([
315 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
316 indexRoute,
317 ])
318β
319 const defaultRouter = createRouter({
320 routeTree,
321 })
322β
323 type DefaultRouter = typeof defaultRouter
324β
325 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
326 Accessor<{
327 indexPage: number
328 }>
329 >()
330β
331 expectTypeOf(useSearch<DefaultRouter, '__root__'>).returns.toEqualTypeOf<
332 Accessor<{}>
333 >()
334β
335 expectTypeOf(useSearch<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
336 Accessor<{}>
337 >()
338β
339 expectTypeOf(useSearch<DefaultRouter, '/invoices'>)
340 .parameter(0)
341 .toHaveProperty('select')
342 .toEqualTypeOf<((search: {}) => unknown) | undefined>()
343β
344 expectTypeOf(
345 useSearch<DefaultRouter, '/invoices', false>,
346 ).returns.toEqualTypeOf<Accessor<{ indexPage?: number }>>()
347β
348 expectTypeOf(useSearch<DefaultRouter, '/invoices', false>)
349 .parameter(0)
350 .toHaveProperty('select')
351 .toEqualTypeOf<
352 ((search: { indexPage?: number }) => unknown) | undefined
353 >()
354 })
355β
356 test('when the root has search params but the index route does not', () => {
357 const rootRoute = createRootRoute({
358 validateSearch: () => ({ rootPage: 0 }),
359 })
360β
361 const indexRoute = createRoute({
362 getParentRoute: () => rootRoute,
363 path: '/',
364 })
365β
366 const invoicesRoute = createRoute({
367 getParentRoute: () => rootRoute,
368 path: 'invoices',
369 })
370β
371 const invoicesIndexRoute = createRoute({
372 getParentRoute: () => invoicesRoute,
373 path: '/',
374 })
375β
376 const invoiceRoute = createRoute({
377 getParentRoute: () => invoicesRoute,
378 path: '$invoiceId',
379 })
380β
381 const routeTree = rootRoute.addChildren([
382 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
383 indexRoute,
384 ])
385β
386 const defaultRouter = createRouter({
387 routeTree,
388 })
389β
390 type DefaultRouter = typeof defaultRouter
391β
392 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
393 Accessor<{
394 rootPage: number
395 }>
396 >()
397β
398 expectTypeOf(useSearch<DefaultRouter, '__root__'>).returns.toEqualTypeOf<
399 Accessor<{
400 rootPage: number
401 }>
402 >()
403β
404 expectTypeOf(useSearch<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
405 Accessor<{
406 rootPage: number
407 }>
408 >()
409β
410 expectTypeOf(useSearch<DefaultRouter, '/invoices'>)
411 .parameter(0)
412 .toHaveProperty('select')
413 .toEqualTypeOf<((search: { rootPage: number }) => unknown) | undefined>()
414β
415 expectTypeOf(
416 useSearch<DefaultRouter, '/invoices', false>,
417 ).returns.toEqualTypeOf<Accessor<{ rootPage?: number }>>()
418β
419 expectTypeOf(useSearch<DefaultRouter, '/invoices', false>)
420 .parameter(0)
421 .toHaveProperty('select')
422 .toEqualTypeOf<((search: { rootPage?: number }) => unknown) | undefined>()
423 })
424β
425 test('when the root has search params but the index does', () => {
426 const rootRoute = createRootRoute({
427 validateSearch: () => ({ rootPage: 0 }),
428 })
429β
430 const indexRoute = createRoute({
431 getParentRoute: () => rootRoute,
432 path: '/',
433 validateSearch: () => ({ indexPage: 0 }),
434 })
435β
436 const invoicesRoute = createRoute({
437 getParentRoute: () => rootRoute,
438 path: 'invoices',
439 })
440β
441 const invoicesIndexRoute = createRoute({
442 getParentRoute: () => invoicesRoute,
443 path: '/',
444 })
445β
446 const invoiceRoute = createRoute({
447 getParentRoute: () => invoicesRoute,
448 path: '$invoiceId',
449 })
450β
451 const routeTree = rootRoute.addChildren([
452 invoicesRoute.addChildren([invoicesIndexRoute, invoiceRoute]),
453 indexRoute,
454 ])
455β
456 const defaultRouter = createRouter({
457 routeTree,
458 })
459β
460 type DefaultRouter = typeof defaultRouter
461β
462 expectTypeOf(useSearch<DefaultRouter, '/'>).returns.toEqualTypeOf<
463 Accessor<{
464 rootPage: number
465 indexPage: number
466 }>
467 >()
468β
469 expectTypeOf(useSearch<DefaultRouter, '__root__'>).returns.toEqualTypeOf<
470 Accessor<{
471 rootPage: number
472 }>
473 >()
474β
475 expectTypeOf(useSearch<DefaultRouter, '/invoices'>).returns.toEqualTypeOf<
476 Accessor<{
477 rootPage: number
478 }>
479 >()
480β
481 expectTypeOf(useSearch<DefaultRouter, '/invoices'>)
482 .parameter(0)
483 .toHaveProperty('select')
484 .toEqualTypeOf<((search: { rootPage: number }) => unknown) | undefined>()
485β
486 expectTypeOf(
487 useSearch<DefaultRouter, '/invoices', false>,
488 ).returns.toEqualTypeOf<
489 Accessor<{ indexPage?: number; rootPage?: number }>
490 >()
491β
492 expectTypeOf(useSearch<DefaultRouter, '/invoices', false>)
493 .parameter(0)
494 .toHaveProperty('select')
495 .toEqualTypeOf<
496 | ((search: { indexPage?: number; rootPage?: number }) => unknown)
497 | undefined
498 >()
499 })
500β
501 test('when a route has search params using SearchSchemaInput', () => {
502 const rootRoute = createRootRoute()
503β
504 const indexRoute = createRoute({
505 getParentRoute: () => rootRoute,
506 path: '/',
507 validateSearch: (input: { page?: number } & SearchSchemaInput) => {
508 return { page: input.page ?? 0 }
509 },
510 })
511β
512 const routeTree = rootRoute.addChildren([indexRoute])
513β
514 const router = createRouter({ routeTree })
515 expectTypeOf(useSearch<typeof router, '/'>).returns.toEqualTypeOf<
516 Accessor<{
517 page: number
518 }>
519 >
520 })
521β
522 test('when route has a union of search params', () => {
523 const rootRoute = createRootRoute()
524β
525 const postRoute = createRoute({
526 getParentRoute: () => rootRoute,
527 path: '/',
528 validateSearch: (): { status: 'in' } | { status: 'out' } => {
529 return { status: 'in' }
530 },
531 })
532β
533 const indexRoute = createRoute({
534 getParentRoute: () => postRoute,
535 path: '/',
536 validateSearch: (): { detail: string } => {
537 return { detail: 'detail' }
538 },
539 })
540β
541 const routeTree = rootRoute.addChildren([
542 indexRoute.addChildren([indexRoute]),
543 ])
544β
545 const router = createRouter({ routeTree })
546 expectTypeOf(useSearch<typeof router, '/'>).returns.toEqualTypeOf<
547 Accessor<
548 { status: 'in'; detail: string } | { status: 'out'; detail: string }
549 >
550 >
551 })
552β
553 describe('shouldThrow', () => {
554 const rootRoute = createRootRoute()
555β
556 const indexRoute = createRoute({
557 getParentRoute: () => rootRoute,
558 path: '/',
559 })
560β
561 const invoicesRoute = createRoute({
562 getParentRoute: () => rootRoute,
563 path: 'invoices',
564 validateSearch: () => ({ page: 0 }),
565 })
566β
567 const routeTree = rootRoute.addChildren([invoicesRoute, indexRoute])
568β
569 const router = createRouter({ routeTree })
570β
571 const from = '/invoices'
572 test('return type is `{ page: number }` when shouldThrow = true', () => {
573 const shouldThrow = true
574 const search = useSearch<
575 typeof router,
576 typeof from,
577 /* strict */ true,
578 typeof shouldThrow
579 >({ from, shouldThrow })
580β
581 expectTypeOf(search).toEqualTypeOf<Accessor<{ page: number }>>()
582 })
583β
584 test('return type is `{page: number} | undefined` when shouldThrow = false', () => {
585 const shouldThrow = false
586 const search = useSearch<
587 typeof router,
588 typeof from,
589 /* strict */ true,
590 typeof shouldThrow
591 >({ from, shouldThrow })
592β
593 expectTypeOf(search).toEqualTypeOf<
594 Accessor<{ page: number } | undefined>
595 >()
596 })
597 })
598})