one 1.1.473 → 1.1.475

package/src/fork/getPathFromState.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'vitest'
+import type { PathConfigMap } from '@react-navigation/core'
+
+import { getPathFromState, type State } from './getPathFromState'
+
+describe('hash support', () => {
+  it('appends hash to the path', () => {
+    const state = {
+      index: 0,
+      key: 'key',
+      routes: [
+        {
+          name: 'index',
+          path: '/',
+          params: {
+            '#': 'hash1',
+          },
+        },
+      ],
+      stale: true,
+      type: 'stack',
+    }
+
+    const config = {
+      screens: {
+        index: '',
+        _sitemap: '_sitemap',
+      },
+    }
+
+    expect(getPathFromState(state, config)).toBe('/#hash1')
+  })
+
+  it('works with nested state, existing router and path params', () => {
+    const state = {
+      index: 1,
+      key: 'key',
+      routeNames: ['index', '[test]', '_sitemap', '+not-found'],
+      routes: [
+        {
+          key: 'key',
+          name: 'index',
+          params: undefined,
+          path: '/',
+        },
+        {
+          key: 'key',
+          name: '[test]',
+          params: {
+            test: 'hello-world',
+            query: 'true',
+            '#': 'a',
+          },
+          path: undefined,
+        },
+      ],
+      stale: false,
+      type: 'stack',
+    }
+
+    const config = {
+      screens: {
+        '[test]': ':test',
+        index: '',
+        _sitemap: '_sitemap',
+      },
+    }
+
+    expect(getPathFromState(state, config)).toBe('/hello-world?query=true#a')
+  })
+})
+
+// TODO
+it.skip(`handles url search params params`, () => {
+  const state = {
+    routes: [
+      {
+        name: 'index',
+        params: {
+          test: 'true',
+          hello: 'world',
+          array: ['1', '2'],
+        },
+        path: '/?test=true&hello=world&array=1&array=2',
+      },
+    ],
+  }
+
+  const config = {
+    screens: {
+      index: '',
+      _sitemap: '_sitemap',
+    },
+  }
+
+  expect(getPathFromState(state, config)).toBe('/?test=true&hello=world&array=1&array=2')
+})
+
+it(`handles uninitialized state on nested navigation with route params`, () => {
+  const config = {
+    screens: {
+      index: '',
+      '[folderSlugL1]': {
+        path: ':folderSlugL1',
+        screens: {
+          '[folderSlugL2]': {
+            path: ':folderSlugL2',
+            screens: {
+              '[folderSlugL3]': {
+                path: ':folderSlugL3',
+                screens: {
+                  page: 'page',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  } satisfies { screens: PathConfigMap<any> }
+
+  const state = {
+    routes: [
+      {
+        name: '[folderSlugL1]',
+        params: {
+          folderSlugL1: 'foo',
+          screen: '[folderSlugL2]',
+          params: {
+            folderSlugL1: 'foo',
+            folderSlugL2: 'bar',
+            screen: '[folderSlugL3]',
+            params: {
+              folderSlugL1: 'foo',
+              folderSlugL2: 'bar',
+              folderSlugL3: 'baz',
+              screen: 'page',
+            },
+          },
+        },
+      },
+    ],
+  } satisfies State
+
+  expect(getPathFromState(state, config)).toBe('/foo/bar/baz/page')
+})

package/src/fork/getPathFromState.ts

@@ -233,7 +233,7 @@ export function getPathDataFromState<ParamList extends {}>(
               : undefined
 
         if (screen && screens && currentOptions[route.name].screens?.[screen]) {
-          route = { ...screens[screen], name: screen, key: screen }
+          route = { ...screens[screen], name: screen, key: screen, params: (route.params as any)?.params }
           currentOptions = screens
         } else {
           hasNext = false

package/src/fork/getStateFromPath.test.ts

@@ -0,0 +1,345 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { getMockConfig } from '../testing-utils'
+import { getPathFromState } from './getPathFromState'
+import { getStateFromPath } from './getStateFromPath'
+import { getUrlWithReactNavigationConcessions, stripBaseUrl } from './getStateFromPath-mods'
+
+
+
+describe(stripBaseUrl, () => {
+  ;[
+    [
+      // Input
+      '/',
+      // Base Path
+      '',
+      // Result
+      '/',
+    ],
+    ['/one/two', '/one', '/two'],
+    ['/one/two', '/one/two', ''],
+    ['/one/two/', '/one/two', '/'],
+    ['///one/', '/one', '/'],
+    ['one/', '/one', 'one/'],
+    ['/a/b', '/one', '/a/b'],
+  ].forEach(([path, baseUrl, result]) => {
+    it(`strips baseUrl "${path}"`, () => {
+      expect(stripBaseUrl(path, baseUrl)).toBe(result)
+    })
+  })
+})
+
+describe('baseUrl', () => {
+  beforeEach(() => {
+    process.env.ONE_DEFAULT_RENDER_MODE = 'spa'
+  })
+
+  it('accounts for baseUrl', () => {
+    process.env.EXPO_BASE_URL = '/expo/prefix'
+
+    const path = '/expo/prefix/bar'
+    const config = getMockConfig(['_layout.tsx', 'bar.tsx', 'index.tsx'])
+
+    expect(getStateFromPath<object>(path, config)).toEqual({
+      routes: [{ name: 'bar', path: '/bar' }],
+    })
+
+    expect(getPathFromState(getStateFromPath<object>(path, config)!, config)).toBe(
+      '/expo/prefix/bar'
+    )
+  })
+
+  it('has baseUrl and state that does not match', () => {
+    process.env.EXPO_BASE_URL = '/expo'
+    const path = '/bar'
+    const config = getMockConfig(['_layout.tsx', 'bar.tsx', 'index.tsx'])
+
+    expect(getStateFromPath<object>(path, config)).toEqual({
+      routes: [{ name: 'bar', path: '/bar' }],
+    })
+    expect(getPathFromState(getStateFromPath<object>(path, config)!, config)).toBe('/expo/bar')
+  })
+})
+
+describe(getUrlWithReactNavigationConcessions, () => {
+  beforeEach(() => {
+    delete process.env.EXPO_BASE_URL
+  })
+
+  ;['/', 'foo/', 'foo/bar/', 'foo/bar/baz/'].forEach((path) => {
+    it(`returns the pathname for ${path}`, () => {
+      expect(getUrlWithReactNavigationConcessions(path).nonstandardPathname).toBe(path)
+    })
+  })
+
+  ;[
+    ['', '/'],
+    ['https://acme.com/hello/world?foo=bar#123', 'hello/world/'],
+    ['https://acme.com/hello/world/?foo=bar#123', 'hello/world/'],
+  ].forEach(([url, expected]) => {
+    it(`returns the pathname for ${url}`, () => {
+      expect(getUrlWithReactNavigationConcessions(url).nonstandardPathname).toBe(expected)
+    })
+  })
+
+  ;[
+    ['/gh-pages/', '/'],
+    ['https://acme.com/gh-pages/hello/world?foo=bar#123', 'hello/world/'],
+    ['https://acme.com/gh-pages/hello/world/?foo=bar#123', 'hello/world/'],
+  ].forEach(([url, expected]) => {
+    it(`returns the pathname for ${url}`, () => {
+      expect(getUrlWithReactNavigationConcessions(url, 'gh-pages').nonstandardPathname).toBe(
+        expected
+      )
+    })
+  })
+})
+
+describe('hash', () => {
+  it(`parses hashes`, () => {
+    expect(
+      getStateFromPath('/hello#123', {
+        screens: {
+          hello: 'hello',
+        },
+      } as any)
+    ).toEqual({
+      routes: [
+        {
+          name: 'hello',
+          path: '/hello#123',
+          params: {
+            '#': '123',
+          },
+        },
+      ],
+    })
+  })
+
+  it('parses hashes with dynamic routes', () => {
+    expect(getStateFromPath('/hello#123', getMockConfig(['[hello]']))).toEqual({
+      routes: [
+        {
+          name: '[hello]',
+          params: {
+            hello: 'hello',
+            '#': '123',
+          },
+          path: '/hello#123',
+        },
+      ],
+    })
+  })
+
+  it('parses hashes with query params', () => {
+    expect(getStateFromPath('/?#123', getMockConfig(['index']))).toEqual({
+      routes: [
+        {
+          name: 'index',
+          path: '/?#123',
+          params: {
+            '#': '123',
+          },
+        },
+      ],
+    })
+
+    // TODO: Test rest params
+  })
+})
+
+it(`supports spaces`, () => {
+  expect(
+    getStateFromPath('/hello%20world', {
+      screens: {
+        'hello world': 'hello world',
+      },
+    } as any)
+  ).toEqual({
+    routes: [
+      {
+        name: 'hello world',
+        path: '/hello%20world',
+      },
+    ],
+  })
+
+  expect(getStateFromPath('/hello%20world', getMockConfig(['[hello world]']))).toEqual({
+    routes: [
+      {
+        name: '[hello world]',
+        params: {
+          'hello world': 'hello world',
+        },
+        path: '/hello%20world',
+      },
+    ],
+  })
+
+  // TODO: Test rest params
+})
+
+// TODO
+it.skip(`matches against dynamic groups`, () => {
+  /*
+   * This will match (app)/([user])/[user]/index with a user = '(explore)'
+   * It may appear that '(explore)' is a group name but there is not value to match '[user]'
+   * So it doesn't match any routes in the '(explore)' group
+   * Therefore, '(explore)' is used as the value for '[user]'
+   */
+  expect(
+    getStateFromPath(
+      '/(app)/(explore)',
+      getMockConfig([
+        '+not-found',
+        '(app)/_layout',
+        '(app)/(explore)/_layout',
+        '(app)/(explore)/[user]/index',
+        '(app)/(explore)/explore',
+
+        '(app)/([user])/_layout',
+        '(app)/([user])/[user]/index',
+        '(app)/([user])/explore',
+      ])
+    )
+  ).toEqual({
+    routes: [
+      {
+        name: '(app)',
+        params: { user: '(explore)' },
+        state: {
+          routes: [
+            {
+              name: '([user])',
+              params: { user: '(explore)' },
+              state: {
+                routes: [
+                  {
+                    name: '[user]/index',
+                    params: { user: '(explore)' },
+                    path: '',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      },
+    ],
+  })
+})
+
+it(`adds dynamic route params from all levels of the path`, () => {
+  // A route at `app/[foo]/bar/[baz]/other` should get all of the params from the path.
+  expect(
+    getStateFromPath(
+      '/foo/bar/baz/other',
+
+      getMockConfig([
+        '[foo]/_layout.tsx',
+        '[foo]/bar/_layout.tsx',
+        '[foo]/bar/[baz]/_layout.tsx',
+        '[foo]/bar/[baz]/other.tsx',
+      ])
+    )
+  ).toEqual({
+    routes: [
+      {
+        name: '[foo]',
+        params: { baz: 'baz', foo: 'foo' },
+        state: {
+          routes: [
+            {
+              name: 'bar',
+              params: { baz: 'baz', foo: 'foo' },
+              state: {
+                routes: [
+                  {
+                    name: '[baz]',
+                    params: { baz: 'baz', foo: 'foo' },
+                    state: {
+                      routes: [
+                        {
+                          name: 'other',
+                          params: {
+                            baz: 'baz',
+                            foo: 'foo',
+                          },
+                          path: '/foo/bar/baz/other',
+                        },
+                      ],
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      },
+    ],
+  })
+})
+
+it(`handles not-found routes`, () => {
+  expect(getStateFromPath('/missing-page', getMockConfig(['+not-found', 'index']))).toEqual({
+    routes: [
+      {
+        name: '+not-found',
+        params: {
+          'not-found': ['missing-page'],
+        },
+        path: '/missing-page',
+      },
+    ],
+  })
+})
+
+it(`handles query params`, () => {
+  expect(
+    getStateFromPath('/?test=true&hello=world&array=1&array=2', getMockConfig(['index.tsx']))
+  ).toEqual({
+    routes: [
+      {
+        name: 'index',
+        params: {
+          test: 'true',
+          hello: 'world',
+          array: ['1', '2'],
+        },
+        path: '/?test=true&hello=world&array=1&array=2',
+      },
+    ],
+  })
+})
+
+it(`handles query params`, () => {
+  expect(
+    getStateFromPath('/?test=true&hello=world&array=1&array=2', getMockConfig(['index.tsx']))
+  ).toEqual({
+    routes: [
+      {
+        name: 'index',
+        params: {
+          test: 'true',
+          hello: 'world',
+          array: ['1', '2'],
+        },
+        path: '/?test=true&hello=world&array=1&array=2',
+      },
+    ],
+  })
+})
+
+// TODO
+it.skip(`prioritizes hoisted index routes over dynamic groups`, () => {
+  expect(
+    getStateFromPath('/(one)', getMockConfig(['(one,two)/index.tsx', '(one,two)/[slug].tsx']))
+  ).toEqual({
+    routes: [
+      {
+        name: '(one)/index',
+        path: '',
+      },
+    ],
+  })
+})

package/src/render.tsx

@@ -14,9 +14,9 @@ export function render(element: React.ReactNode) {
     globalThis['__vxrnRoot'].render(element)
   } else {
     startTransition(() => {
-      const rootElement = process.env.ONE_FIX_REACT_PORTAL_BUG
-        ? (document as any)
-        : document.documentElement
+      const rootElement = process.env.ONE_USE_FASTER_DOCUMENT
+        ? document.documentElement
+        : (document as any)
 
       if (globalThis['__vxrnIsSPA']) {
         const root = createRoot(rootElement)

package/src/router/FlagsContext.ts

@@ -0,0 +1,4 @@
+import { createContext } from 'react'
+import type { One } from '../vite/types'
+
+export const FlagsContext = createContext<One.Flags>({})

package/src/router/getRoutes.ts

@@ -242,8 +242,20 @@ function getDirectoryTree(contextModule: One.RouteContext, options: Options) {
       {
         type: 'layout',
         loadRoute: () => ({
-          default: (require('../views/Navigator') as typeof import('../views/Navigator'))
-            .DefaultNavigator,
+          default: (
+            (() => {
+              try {
+                return require('../views/Navigator')
+              } catch (e) {
+                // This can happen during unit testing with vitest, where we cannot just require TypeScript files. Currently we will not actually render the navigator in tests, so it's fine to mock it this way but still bring awareness of what's happening if it happens in actual runtime.
+                return {
+                  DefaultNavigator: () => {
+                    throw e
+                  },
+                }
+              }
+            })() as typeof import('../views/Navigator')
+          ).DefaultNavigator,
         }),
         // Generate a fake file name for the directory
         contextKey: 'router/build/views/Navigator.js',

package/src/router/matchers.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest'
+import {
+  matchDynamicName,
+  matchDeepDynamicRouteName,
+  getNameFromFilePath,
+  matchGroupName,
+  stripGroupSegmentsFromPath,
+  matchArrayGroupName,
+} from './matchers'
+
+describe(stripGroupSegmentsFromPath, () => {
+  it(`strips group segments, preserving initial slash`, () => {
+    expect(stripGroupSegmentsFromPath('/[[...foobar]]/(foo)/bar/[bax]/(other)')).toBe(
+      '/[[...foobar]]/bar/[bax]'
+    )
+    expect(stripGroupSegmentsFromPath('(foo)/(bar)')).toBe('')
+  })
+})
+
+describe(matchGroupName, () => {
+  it(`matches`, () => {
+    expect(matchGroupName('[[...foobar]]')).toEqual(undefined)
+    expect(matchGroupName('[[foobar]]')).toEqual(undefined)
+    expect(matchGroupName('[...foobar]')).toEqual(undefined)
+    expect(matchGroupName('[foobar]')).toEqual(undefined)
+    expect(matchGroupName('(foobar)')).toEqual('foobar')
+    expect(matchGroupName('(foo,bar)')).toEqual('foo,bar')
+    expect(matchGroupName('((foobar))')).toEqual('(foobar)')
+    expect(matchGroupName('(...foobar)')).toEqual('...foobar')
+    expect(matchGroupName('foobar')).toEqual(undefined)
+    expect(matchGroupName('leading/foobar')).toEqual(undefined)
+    expect(matchGroupName('leading/(foobar)')).toEqual('foobar')
+    expect(matchGroupName('leading/((foobar))')).toEqual('(foobar)')
+    expect(matchGroupName('leading/(...foobar)')).toEqual('...foobar')
+    expect(matchGroupName('leading/(foo,bar)')).toEqual('foo,bar')
+    expect(matchGroupName('leading/foobar/trailing')).toEqual(undefined)
+    expect(matchGroupName('leading/(foobar)/trailing')).toEqual('foobar')
+    expect(matchGroupName('leading/((foobar))/trailing')).toEqual('(foobar)')
+    expect(matchGroupName('leading/(...foobar)/trailing')).toEqual('...foobar')
+    expect(matchGroupName('leading/(foo,bar)/trailing)')).toEqual('foo,bar')
+    expect(matchGroupName('leading/(foo,bar)/(fruit,apple)')).toEqual('foo,bar')
+  })
+})
+
+describe(matchDynamicName, () => {
+  it(`matches`, () => {
+    expect(matchDynamicName('[[...foobar]]')).toEqual(undefined)
+    expect(matchDynamicName('[[foobar]]')).toEqual(undefined)
+    expect(matchDynamicName('[...foobar]')).toEqual(undefined)
+    expect(matchDynamicName('[foobar]')).toEqual('foobar')
+    expect(matchDynamicName('foobar')).toEqual(undefined)
+  })
+})
+
+describe(matchDeepDynamicRouteName, () => {
+  it(`matches`, () => {
+    expect(matchDeepDynamicRouteName('[[...foobar]]')).toEqual(undefined)
+    expect(matchDeepDynamicRouteName('[[foobar]]')).toEqual(undefined)
+    expect(matchDeepDynamicRouteName('[...foobar]')).toEqual('foobar')
+    expect(matchDeepDynamicRouteName('[foobar]')).toEqual(undefined)
+    expect(matchDeepDynamicRouteName('foobar')).toEqual(undefined)
+  })
+})
+
+describe(getNameFromFilePath, () => {
+  it(`should return the name of the file`, () => {
+    expect(getNameFromFilePath('./pages/home.tsx')).toBe('pages/home')
+    expect(getNameFromFilePath('../pages/home.js')).toBe('pages/home')
+    expect(getNameFromFilePath('./(home).jsx')).toBe('(home)')
+    expect(getNameFromFilePath('../../../(pages)/[any]/[...home].ts')).toBe(
+      '(pages)/[any]/[...home]'
+    )
+  })
+})
+
+describe(matchArrayGroupName, () => {
+  it(`should not match routes without groups`, () => {
+    expect(matchArrayGroupName('[[...foobar]]')).toEqual(undefined)
+    expect(matchArrayGroupName('[[foobar]]')).toEqual(undefined)
+    expect(matchArrayGroupName('[...foobar]')).toEqual(undefined)
+    expect(matchArrayGroupName('[foobar]')).toEqual(undefined)
+    expect(matchArrayGroupName('foobar')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/foobar')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/foobar/trailing')).toEqual(undefined)
+  })
+  it(`should not match routes with a single group`, () => {
+    expect(matchArrayGroupName('(foobar)')).toEqual(undefined)
+    expect(matchArrayGroupName('((foobar))')).toEqual(undefined)
+    expect(matchArrayGroupName('(...foobar)')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/(foobar)')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/((foobar))')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/(...foobar)')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/(foobar)/trailing')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/((foobar))/trailing')).toEqual(undefined)
+    expect(matchArrayGroupName('leading/(...foobar)/trailing')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/foobar')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/(foobar)')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/((foobar))')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/(...foobar)')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/foobar/trailing')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/(foobar)/trailing')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/((foobar))/trailing')).toEqual(undefined)
+    expect(matchArrayGroupName('(leading)/(...foobar)/trailing')).toEqual(undefined)
+  })
+  it.skip(`should match routes with array group syntax`, () => {
+    expect(matchArrayGroupName('(foo,bar)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('leading/(foo,bar)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('leading/(foo,bar)/trailing)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('leading/((foo),(bar))/trailing)')).toEqual('(foo),(bar)')
+    expect(matchArrayGroupName('leading/(foo,bar)/(fruit,apple)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('(leading)/(foo,bar)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('(leading)/(foo,bar)/trailing)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('(leading)/((foo),(bar))/trailing)')).toEqual('(foo),(bar)')
+  })
+  it.skip(`should only match the first group with array group syntax`, () => {
+    expect(matchArrayGroupName('(leading)/(foo,bar)/(fruit,apple)')).toEqual('foo,bar')
+    expect(matchArrayGroupName('(leading)/((foo),bar)/(fruit,apple)')).toEqual('(foo),bar')
+    expect(matchArrayGroupName('(leading)/(foo,bar)/((fruit),apple)')).toEqual('foo,bar')
+  })
+})