one 1.2.46 → 1.2.48

package/src/fork/__tests__/getStateFromPath.test.tsx

@@ -94,7 +94,9 @@ test.skip('decodes encoded params in path', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toEqual(path)
+  expect(
+    getPathFromState<object>(getStateFromPath<object>(path, config)!, config)
+  ).toEqual(path)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -131,7 +133,9 @@ test.skip('decodes encoded params in path that have encoded /', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toEqual(path)
+  expect(
+    getPathFromState<object>(getStateFromPath<object>(path, config)!, config)
+  ).toEqual(path)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -148,7 +152,8 @@ test.skip('converts path string to initial state with config', () => {
               Baz: {
                 path: 'baz/:author',
                 parse: {
-                  author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
+                  author: (author: string) =>
+                    author.replace(/^\w/, (c) => c.toUpperCase()),
                   count: Number,
                   valid: Boolean,
                 },
@@ -194,7 +199,9 @@ test.skip('converts path string to initial state with config', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles leading slash when converting', () => {
@@ -276,7 +283,8 @@ test.skip('converts path string to initial state with config with nested screens
                   Baz: {
                     path: 'baz/:author',
                     parse: {
-                      author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
+                      author: (author: string) =>
+                        author.replace(/^\w/, (c) => c.toUpperCase()),
                       count: Number,
                       valid: Boolean,
                     },
@@ -331,7 +339,9 @@ test.skip('converts path string to initial state with config with nested screens
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -349,7 +359,8 @@ test.skip('converts path string to initial state with config with nested screens
               Baz: {
                 path: 'baz/:author',
                 parse: {
-                  author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
+                  author: (author: string) =>
+                    author.replace(/^\w/, (c) => c.toUpperCase()),
                   count: Number,
                   valid: Boolean,
                   id: Boolean,
@@ -392,9 +403,9 @@ test.skip('converts path string to initial state with config with nested screens
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/foe/baz/Jane?count=10&answer=42&valid=true')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/foe/baz/Jane?count=10&answer=42&valid=true'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -419,10 +430,12 @@ test.skip('handles nested object with unused configs and with parse in it', () =
                       Bis: {
                         path: 'bis/:author',
                         stringify: {
-                          author: (author: string) => author.replace(/^\w/, (c) => c.toLowerCase()),
+                          author: (author: string) =>
+                            author.replace(/^\w/, (c) => c.toLowerCase()),
                         },
                         parse: {
-                          author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
+                          author: (author: string) =>
+                            author.replace(/^\w/, (c) => c.toUpperCase()),
                           count: Number,
                           valid: Boolean,
                         },
@@ -483,7 +496,9 @@ test.skip('handles nested object with unused configs and with parse in it', () =
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles parse in nested object for second route depth', () => {
@@ -531,7 +546,9 @@ test('handles parse in nested object for second route depth', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles parse in nested object for second route depth and and path and parse in roots', () => {
@@ -580,7 +597,9 @@ test('handles parse in nested object for second route depth and and path and par
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -615,7 +634,9 @@ test.skip('handles path at top level', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles initialRouteName at top level', () => {
@@ -657,7 +678,9 @@ test('handles initialRouteName at top level', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles initialRouteName inside a screen', () => {
@@ -701,7 +724,9 @@ test('handles initialRouteName inside a screen', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles initialRouteName included in path', () => {
@@ -741,7 +766,9 @@ test('handles initialRouteName included in path', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -767,10 +794,12 @@ test.skip('handles two initialRouteNames', () => {
                       Bis: {
                         path: 'bis/:author',
                         stringify: {
-                          author: (author: string) => author.replace(/^\w/, (c) => c.toLowerCase()),
+                          author: (author: string) =>
+                            author.replace(/^\w/, (c) => c.toLowerCase()),
                         },
                         parse: {
-                          author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
+                          author: (author: string) =>
+                            author.replace(/^\w/, (c) => c.toUpperCase()),
                           count: Number,
                           valid: Boolean,
                         },
@@ -833,7 +862,9 @@ test.skip('handles two initialRouteNames', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -859,10 +890,12 @@ test.skip('accepts initialRouteName without config for it', () => {
                       Bis: {
                         path: 'bis/:author',
                         stringify: {
-                          author: (author: string) => author.replace(/^\w/, (c) => c.toLowerCase()),
+                          author: (author: string) =>
+                            author.replace(/^\w/, (c) => c.toLowerCase()),
                         },
                         parse: {
-                          author: (author: string) => author.replace(/^\w/, (c) => c.toUpperCase()),
+                          author: (author: string) =>
+                            author.replace(/^\w/, (c) => c.toUpperCase()),
                           count: Number,
                           valid: Boolean,
                         },
@@ -925,7 +958,9 @@ test.skip('accepts initialRouteName without config for it', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('returns undefined if no matching screen is present (top level path)', () => {
@@ -1028,9 +1063,9 @@ test.skip('returns matching screen if path is empty', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, ''))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1071,9 +1106,9 @@ test.skip('returns matching screen if path is only slash', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, ''))
 })
 
 test('returns matching screen with params if path is empty', () => {
@@ -1116,9 +1151,9 @@ test('returns matching screen with params if path is empty', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/?foo=42')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/?foo=42'))
 })
 
 test("doesn't match nested screen if path is empty", () => {
@@ -1190,7 +1225,9 @@ test.skip('chooses more exhaustive pattern', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('handles same paths beginnings', () => {
@@ -1232,7 +1269,9 @@ test('handles same paths beginnings', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1279,7 +1318,9 @@ test.skip('handles same paths beginnings with params', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1333,7 +1374,9 @@ test.skip('handles not taking path with too many segments', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1387,7 +1430,9 @@ test.skip('handles differently ordered params v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1441,7 +1486,9 @@ test.skip('handles differently ordered params v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1495,7 +1542,9 @@ test.skip('handles differently ordered params v3', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1549,9 +1598,9 @@ test.skip('handles differently ordered params v4', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/5/foos/res/20')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/5/foos/res/20'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1605,7 +1654,9 @@ test.skip('handles simple optional params', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1659,7 +1710,9 @@ test.skip('handle 2 optional params at the end v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1713,7 +1766,9 @@ test.skip('handle 2 optional params at the end v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1768,7 +1823,9 @@ test.skip('handle 2 optional params at the end v3', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1823,7 +1880,9 @@ test.skip('handle optional params in the middle v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1878,7 +1937,9 @@ test.skip('handle optional params in the middle v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1934,7 +1995,9 @@ test.skip('handle optional params in the middle v3', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -1990,7 +2053,9 @@ test.skip('handle optional params in the middle v4', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2046,7 +2111,9 @@ test.skip('handle optional params in the middle v5', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2102,9 +2169,9 @@ test.skip('handle optional params in the beginning v1', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/5/10/foos/15')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/5/10/foos/15'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2160,9 +2227,9 @@ test.skip('handle optional params in the beginning v2', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/5/10/foos/15')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/5/10/foos/15'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2202,9 +2269,9 @@ test.skip('merges parent patterns if needed', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/foo/42/baz/babel')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/foo/42/baz/babel'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2240,7 +2307,9 @@ test.skip('ignores extra slashes in the pattern', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2264,9 +2333,9 @@ test.skip('matches wildcard patterns at root', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/404')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/404'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2307,9 +2376,9 @@ test.skip('matches wildcard patterns at nested level', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/bar/42/404')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/bar/42/404'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2353,9 +2422,9 @@ test.skip('matches wildcard patterns at nested level with exact', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/404')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/404'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2398,7 +2467,9 @@ test.skip('tries to match wildcard patterns at the end', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2432,9 +2503,9 @@ test.skip('uses nearest parent wildcard match for unmatched paths', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/404')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/404'))
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2468,9 +2539,9 @@ test.skip('matches screen with overlapping initial path and wildcard', () => {
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(
-    changePath(state, '/bar/42/Baz')
-  )
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(changePath(state, '/bar/42/Baz'))
 })
 
 test('throws if two screens map to the same pattern', () => {
@@ -2565,7 +2636,9 @@ test('correctly applies initialRouteName for config with similar route names', (
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 test('correctly applies initialRouteName for config with similar route names v2', () => {
@@ -2623,7 +2696,9 @@ test('correctly applies initialRouteName for config with similar route names v2'
   }
 
   expect(getStateFromPath<object>(path, config)).toEqual(state)
-  expect(getStateFromPath<object>(getPathFromState<object>(state, config), config)).toEqual(state)
+  expect(
+    getStateFromPath<object>(getPathFromState<object>(state, config), config)
+  ).toEqual(state)
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2738,7 +2813,9 @@ test.skip('encodes special characters in params', () => {
   }
 
   expect(getPathFromState<object>(state, config)).toBe(`/${path}`)
-  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toBe(`/${path}`)
+  expect(getPathFromState<object>(getStateFromPath<object>(path, config)!, config)).toBe(
+    `/${path}`
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2792,7 +2869,9 @@ test('parses / same as empty string', () => {
     },
   }
 
-  expect(getStateFromPath<object>('/', config)).toEqual(getStateFromPath<object>('', config))
+  expect(getStateFromPath<object>('/', config)).toEqual(
+    getStateFromPath<object>('', config)
+  )
 })
 
 // @modify: TODO: temporally disable failing test
@@ -2973,13 +3052,17 @@ test.skip('handles alias for paths', () => {
     routes: [{ name: 'Foo', path: 'foo' }],
   })
 
-  expect(getPathFromState<object>(getStateFromPath<object>('foo', config)!, config)).toBe('/foo')
+  expect(getPathFromState<object>(getStateFromPath<object>('foo', config)!, config)).toBe(
+    '/foo'
+  )
 
   expect(getStateFromPath<object>('first', config)).toEqual({
     routes: [{ name: 'Foo', path: 'first' }],
   })
 
-  expect(getPathFromState<object>(getStateFromPath<object>('first', config)!, config)).toBe('/foo')
+  expect(
+    getPathFromState<object>(getStateFromPath<object>('first', config)!, config)
+  ).toBe('/foo')
 
   expect(getStateFromPath<object>('foo/baz/@$test', config)).toEqual({
     routes: [
@@ -3019,9 +3102,9 @@ test.skip('handles alias for paths', () => {
     ],
   })
 
-  expect(getPathFromState<object>(getStateFromPath<object>('second/42', config)!, config)).toBe(
-    '/foo/baz/42'
-  )
+  expect(
+    getPathFromState<object>(getStateFromPath<object>('second/42', config)!, config)
+  ).toBe('/foo/baz/42')
 
   expect(getStateFromPath<object>('foo/third', config)).toEqual({
     routes: [
@@ -3039,9 +3122,9 @@ test.skip('handles alias for paths', () => {
     ],
   })
 
-  expect(getPathFromState<object>(getStateFromPath<object>('foo/third', config)!, config)).toBe(
-    '/foo/baz'
-  )
+  expect(
+    getPathFromState<object>(getStateFromPath<object>('foo/third', config)!, config)
+  ).toBe('/foo/baz')
 
   expect(getStateFromPath<object>('foo/fourth/@$test', config)).toEqual({
     routes: [
@@ -3061,7 +3144,10 @@ test.skip('handles alias for paths', () => {
   })
 
   expect(
-    getPathFromState<object>(getStateFromPath<object>('foo/fourth/@$test', config)!, config)
+    getPathFromState<object>(
+      getStateFromPath<object>('foo/fourth/@$test', config)!,
+      config
+    )
   ).toBe('/foo/baz/@test')
 
   expect(getStateFromPath<object>('foo/qux/42', config)).toEqual({
@@ -3081,9 +3167,9 @@ test.skip('handles alias for paths', () => {
     ],
   })
 
-  expect(getPathFromState<object>(getStateFromPath<object>('foo/qux/42', config)!, config)).toBe(
-    '/foo/qux/42'
-  )
+  expect(
+    getPathFromState<object>(getStateFromPath<object>('foo/qux/42', config)!, config)
+  ).toBe('/foo/qux/42')
 })
 
 // @modify: TODO: temporally disable failing test