test: fix absolute paths tests

Author: posva

packages/router/src/experimental/route-resolver/matcher-resolve.spec.ts

@@ -83,8 +83,6 @@ function compileRouteRecord(
     mergeOptions(PATH_PARSER_OPTIONS_DEFAULTS, record)
   )
 
-  // console.log({ record, parser })
-
   return {
     group: !isMatchable(record),
     name: record.name,
@@ -93,7 +91,6 @@ function compileRouteRecord(
     path: {
       match(value) {
         const params = parser.parse(value)
-        // console.log('🌟', parser.re, value, params)
         if (params) {
           return params
         }
@@ -212,18 +209,13 @@ describe('RouterMatcher.resolve', () => {
           fromLocation
         )
 
-    // console.log(matcher.getMatchers())
-    // console.log({ toLocation, resolved, expectedLocation, resolvedFrom })
-
     const result = matcher.resolve(
       // FIXME: should work now
       // @ts-expect-error
       toLocation,
       resolvedFrom === START_LOCATION ? undefined : resolvedFrom
     )
 
-    // console.log(result)
-
     if (
       expectedLocation.name === undefined ||
       expectedLocation.name !== NO_MATCH_LOCATION.name

packages/router/src/experimental/route-resolver/resolver-static.spec.ts

@@ -55,13 +55,13 @@ describe('StaticResolver', () => {
   })
 
   describe('resolve()', () => {
-    describe.todo('absolute locations as strings', () => {
+    describe('absolute locations as strings', () => {
       it('resolves string locations with no params', () => {
         const resolver = createStaticResolver([
           { name: 'root', path: EMPTY_PATH_PATTERN_MATCHER },
         ])
 
-        expect(resolver.resolve({ path: '/?a=a&b=b#h' })).toMatchObject({
+        expect(resolver.resolve('/?a=a&b=b#h')).toMatchObject({
           path: '/',
           params: {},
           query: { a: 'a', b: 'b' },
@@ -71,7 +71,7 @@ describe('StaticResolver', () => {
 
       it('resolves a not found string', () => {
         const resolver = createStaticResolver([])
-        expect(resolver.resolve({ path: '/bar?q=1#hash' })).toEqual({
+        expect(resolver.resolve('/bar?q=1#hash')).toEqual({
           ...NO_MATCH_LOCATION,
           fullPath: '/bar?q=1#hash',
           path: '/bar',
@@ -86,20 +86,18 @@ describe('StaticResolver', () => {
           { name: 'user-detail', path: USER_ID_PATH_PATTERN_MATCHER },
         ])
 
-        expect(resolver.resolve({ path: '/users/1?a=a&b=b#h' })).toMatchObject({
+        expect(resolver.resolve('/users/1?a=a&b=b#h')).toMatchObject({
           path: '/users/1',
           params: { id: 1 },
           query: { a: 'a', b: 'b' },
           hash: '#h',
         })
-        expect(resolver.resolve({ path: '/users/54?a=a&b=b#h' })).toMatchObject(
-          {
-            path: '/users/54',
-            params: { id: 54 },
-            query: { a: 'a', b: 'b' },
-            hash: '#h',
-          }
-        )
+        expect(resolver.resolve('/users/54?a=a&b=b#h')).toMatchObject({
+          path: '/users/54',
+          params: { id: 54 },
+          query: { a: 'a', b: 'b' },
+          hash: '#h',
+        })
       })
 
       it('resolve string locations with query', () => {
@@ -111,17 +109,15 @@ describe('StaticResolver', () => {
           },
         ])
 
-        expect(resolver.resolve({ path: '/foo?page=100&b=b#h' })).toMatchObject(
-          {
-            params: { page: 100 },
-            path: '/foo',
-            query: {
-              page: '100',
-              b: 'b',
-            },
-            hash: '#h',
-          }
-        )
+        expect(resolver.resolve('/foo?page=100&b=b#h')).toMatchObject({
+          params: { page: 100 },
+          path: '/foo',
+          query: {
+            page: '100',
+            b: 'b',
+          },
+          hash: '#h',
+        })
       })
 
       it('resolves string locations with hash', () => {
@@ -133,7 +129,7 @@ describe('StaticResolver', () => {
           },
         ])
 
-        expect(resolver.resolve({ path: '/foo?a=a&b=b#bar' })).toMatchObject({
+        expect(resolver.resolve('/foo?a=a&b=b#bar')).toMatchObject({
           hash: '#bar',
           params: { hash: 'bar' },
           path: '/foo',
@@ -151,9 +147,7 @@ describe('StaticResolver', () => {
           },
         ])
 
-        expect(
-          resolver.resolve({ path: '/users/24?page=100#bar' })
-        ).toMatchObject({
+        expect(resolver.resolve('/users/24?page=100#bar')).toMatchObject({
           params: { id: 24, page: 100, hash: 'bar' },
         })
       })
@@ -258,6 +252,19 @@ describe('StaticResolver', () => {
           hash: '',
         })
       })
+
+      it('treats object path as pathname only (no query/hash parsing)', () => {
+        const resolver = createStaticResolver([
+          { name: 'any-path', path: ANY_PATH_PATTERN_MATCHER },
+        ])
+        // Object with path containing query/hash should treat entire string as pathname
+        expect(resolver.resolve({ path: '/?a=a&b=b#h' })).toMatchObject({
+          path: '/?a=a&b=b#h', // Full string treated as path
+          query: {}, // Empty query
+          hash: '', // Empty hash
+          params: { pathMatch: '/?a=a&b=b#h' }, // Matcher sees full string
+        })
+      })
     })
 
     describe('named locations', () => {

packages/router/src/experimental/route-resolver/resolver-static.ts

@@ -149,6 +149,8 @@ export function createStaticResolver<
   function resolve(
     ...[to, currentLocation]: _resolveArgs
   ): ResolverLocationResolved<TRecord> {
+    // named location, e.g. { name: 'foo', params }
+    // or relative location (second argument is current location)
     if (typeof to === 'object' && (to.name || to.path == null)) {
       // relative location by path or by name
       if (__DEV__ && to.name == null && currentLocation == null) {