one 1.10.6 → 1.11.0

package/src/utils/removeParams.ts

@@ -0,0 +1,40 @@
+import type { NavigationState, PartialState } from '@react-navigation/native'
+
+type AnyState = NavigationState | PartialState<NavigationState>
+
+/**
+ * removes specified params from all routes at every nesting level of a navigation state
+ */
+export function removeParams<T extends AnyState>(state: T, paramNames: string[]): T {
+  if (!state?.routes) return state
+
+  return {
+    ...state,
+    routes: state.routes.map((route) => {
+      let newRoute = route
+
+      if (route.params) {
+        const filtered = { ...route.params }
+        let changed = false
+        for (const name of paramNames) {
+          if (name in filtered) {
+            delete (filtered as Record<string, unknown>)[name]
+            changed = true
+          }
+        }
+        if (changed) {
+          newRoute = { ...newRoute, params: filtered }
+        }
+      }
+
+      if (route.state) {
+        const newState = removeParams(route.state as AnyState, paramNames)
+        if (newState !== route.state) {
+          newRoute = { ...newRoute, state: newState as any }
+        }
+      }
+
+      return newRoute
+    }),
+  } as T
+}

package/src/vercel/build/buildVercelOutputDirectory.ts

@@ -1,7 +1,7 @@
 import { join, resolve } from 'node:path'
 
 import FSExtra from 'fs-extra'
-import type { RollupOutput } from 'rollup'
+import type { RolldownOutput } from 'rolldown'
 import { isMatching, P } from 'ts-pattern'
 import type { One } from '../../vite/types'
 import { vercelBuildOutputConfigBase } from './config/vc-build-output-config-base'
@@ -22,13 +22,15 @@ async function moveAllFiles(src: string, dest: string) {
 }
 
 function getMiddlewaresByNamedRegex(buildInfoForWriting: One.BuildInfo) {
+  const outDir = buildInfoForWriting.outDir || 'dist'
+  const prefix = `${outDir}/middlewares/`
   return buildInfoForWriting.manifest.allRoutes
     .filter((r) => r.middlewares && r.middlewares.length > 0)
     .map((r) => [
       r.namedRegex,
       r.middlewares!.map((m) =>
-        m.contextKey.startsWith('dist/middlewares/')
-          ? m.contextKey.substring('dist/middlewares/'.length)
+        m.contextKey.startsWith(prefix)
+          ? m.contextKey.substring(prefix.length)
           : m.contextKey
       ),
     ])
@@ -42,12 +44,14 @@ export const buildVercelOutputDirectory = async ({
   oneOptionsRoot,
   postBuildLogs,
 }: {
-  apiOutput: RollupOutput | null
+  apiOutput: RolldownOutput | null
   buildInfoForWriting: One.BuildInfo
   clientDir: string
   oneOptionsRoot: string
   postBuildLogs: string[]
 }) => {
+  const outDir = buildInfoForWriting.outDir || 'dist'
+
   // clean the vercel output directory to avoid stale files from previous builds
   const vercelOutputDir = resolve(join(oneOptionsRoot, '.vercel/output'))
   if (existsSync(vercelOutputDir)) {
@@ -73,7 +77,8 @@ export const buildVercelOutputDirectory = async ({
           route,
           compiledRoute.code,
           oneOptionsRoot,
-          postBuildLogs
+          postBuildLogs,
+          outDir
         )
       } else {
         console.warn(
@@ -112,7 +117,7 @@ export const buildVercelOutputDirectory = async ({
     }
   }
 
-  const distMiddlewareDir = resolve(join(oneOptionsRoot, 'dist', 'middlewares'))
+  const distMiddlewareDir = resolve(join(oneOptionsRoot, outDir, 'middlewares'))
   if (existsSync(distMiddlewareDir)) {
     const vercelMiddlewareDir = resolve(
       join(oneOptionsRoot, '.vercel/output/functions/_middleware.func')
@@ -122,7 +127,7 @@ export const buildVercelOutputDirectory = async ({
       `[one.build][vercel] copying middlewares from ${distMiddlewareDir} to ${vercelMiddlewareDir}`
     )
     await moveAllFiles(
-      resolve(join(oneOptionsRoot, 'dist', 'middlewares')),
+      resolve(join(oneOptionsRoot, outDir, 'middlewares')),
       vercelMiddlewareDir
     )
     const vercelMiddlewarePackageJsonFilePath = resolve(

package/src/vercel/build/generate/createApiServerlessFunction.ts

@@ -18,7 +18,8 @@ export async function createApiServerlessFunction(
   route: RouteInfo<string>,
   code: string,
   oneOptionsRoot: string,
-  postBuildLogs: string[]
+  postBuildLogs: string[],
+  outDir = 'dist'
 ) {
   try {
     const path = getPathFromRoute(route, { includeIndex: true })
@@ -45,7 +46,7 @@ export async function createApiServerlessFunction(
     postBuildLogs.push(
       `[one.build][vercel.createSsrServerlessFunction] copy shared assets to ${distAssetsFolder}`
     )
-    const sourceAssetsFolder = resolve(join(oneOptionsRoot, 'dist', 'api', 'assets'))
+    const sourceAssetsFolder = resolve(join(oneOptionsRoot, outDir, 'api', 'assets'))
     if (await FSExtra.pathExists(sourceAssetsFolder)) {
       await fs.copy(sourceAssetsFolder, distAssetsFolder)
     }

package/src/vercel/build/generate/createSsrServerlessFunction.ts

@@ -23,7 +23,8 @@ export async function createSsrServerlessFunction(
     )
     await fs.ensureDir(funcFolder)
 
-    const distServerFrom = resolve(join(oneOptionsRoot, 'dist', 'server'))
+    const outDir = buildInfo.outDir || 'dist'
+    const distServerFrom = resolve(join(oneOptionsRoot, outDir, 'server'))
     const distServerTo = resolve(join(funcFolder, 'server'))
     await fs.ensureDir(distServerTo)
     postBuildLogs.push(
@@ -118,7 +119,7 @@ export async function createSsrServerlessFunction(
       route = buildInfoConfig.default.routeToBuildInfo[routeName];
     }
 
-    const exported = await import(route.serverJsPath.replace('dist/','../'))
+    const exported = await import(route.serverJsPath.replace('${outDir}/','../'))
     const loaderData = await exported.loader?.(loaderProps)
 
     // For loader requests, return the loader data as a JavaScript module

package/src/views/Navigator.tsx

@@ -240,6 +240,10 @@ export function useSlot() {
     return null
   }
 
+  if (!state.routes) {
+    return null
+  }
+
   const current = state.routes[state.index]
 
   if (!current) {

package/src/vite/one-server-only.native.ts

@@ -2,7 +2,10 @@ export const requestAsyncLocalStore = null
 export const asyncHeadersCache = new WeakMap()
 export async function setResponseHeaders(cb) {}
 export function mergeHeaders(onto, from) {}
+export function ensureAsyncLocalID() {}
+export async function runWithAsyncLocalContext(cb) {}
 export function setServerContext() {}
 export function setServerData() {}
+export function getServerContext() {}
 export function useServerContext() {}
 export function getServerData() {}

package/src/vite/one-server-only.tsx

@@ -47,8 +47,12 @@ export async function runWithAsyncLocalContext<A>(
 
 export async function setResponseHeaders(cb: (headers: Headers) => void) {
   const id = ensureAsyncLocalID()
-  const headers = asyncHeadersCache.get(id) ?? new Headers()
-  asyncHeadersCache.set(id, headers)
+  // read from globalThis to work in bundled middleware where module-level
+  // vars may be lazily initialized by the bundler (rolldown __esmMin)
+  const cache: WeakMap<any, Headers> =
+    globalThis['__vxrnasyncHeadersCache'] ?? asyncHeadersCache
+  const headers = cache.get(id) ?? new Headers()
+  cache.set(id, headers)
   cb(headers)
 }
 
@@ -76,9 +80,13 @@ export function ensureAsyncLocalID() {
   // since Vercel ultimately deploys to AWS Lambda, which does not have this issue
   // The Error you willl see is something like this:
   //    Error: Internal One error, no AsyncLocalStorage id! at ensureAsyncLocalID (file:///var/task/server/_virtual_one-entry.js:37411:64)
-  const id = process.env.VERCEL
-    ? globalThis[GLOBAL_ID_KEY]
-    : requestAsyncLocalStore?.getStore()
+
+  // read from globalThis to work in bundled middleware where module-level
+  // vars may be lazily initialized by the bundler (rolldown __esmMin)
+  const globalIdKey = GLOBAL_ID_KEY || '__oneGlobalContextId'
+  const store = requestAsyncLocalStore ?? globalThis['__vxrnrequestAsyncLocalStore']
+
+  const id = process.env.VERCEL ? globalThis[globalIdKey] : store?.getStore()
 
   if (!id) {
     throw new Error(`Internal One error, no AsyncLocalStorage id!`)

package/src/vite/one.ts

@@ -6,9 +6,9 @@ import {
   getPlatformEnvDefine,
 } from '@vxrn/vite-plugin-metro'
 import events from 'node:events'
+import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { type Plugin, type PluginOption } from 'vite'
-import tsconfigPaths from 'vite-tsconfig-paths'
 import { autoDepOptimizePlugin, getOptionsFilled, loadEnv } from 'vxrn'
 import vxrnVitePlugin from 'vxrn/vite-plugin'
 import { CACHE_KEY } from '../constants'
@@ -22,6 +22,7 @@ import { createDevtoolsPlugin } from './plugins/devtoolsPlugin'
 import { createFileSystemRouterPlugin } from './plugins/fileSystemRouterPlugin'
 import { fixDependenciesPlugin } from './plugins/fixDependenciesPlugin'
 import { generateFileSystemRouteTypesPlugin } from './plugins/generateFileSystemRouteTypesPlugin'
+import { criticalCSSPlugin } from './plugins/criticalCSSPlugin'
 import { imageDataPlugin } from './plugins/imageDataPlugin'
 import { sourceInspectorPlugin } from './plugins/sourceInspectorPlugin'
 import { SSRCSSPlugin } from './plugins/SSRCSSPlugin'
@@ -169,6 +170,8 @@ export function one(options: One.PluginOptions = {}): PluginOption {
 
     environmentGuardPlugin(options.environmentGuards),
 
+    criticalCSSPlugin(),
+
     imageDataPlugin(),
 
     {
@@ -217,36 +220,131 @@ export function one(options: One.PluginOptions = {}): PluginOption {
       ? []
       : [
           (() => {
-            const pathsConfig = options.config?.tsConfigPaths
-            const skipDotDirs = (dir: string) => {
-              const name = dir.split('/').pop() || ''
-              return name.startsWith('.')
+            // vite 8's native resolve.tsconfigPaths works for client but fetchModule
+            // hardcodes tsconfigPaths: false for SSR, so we also resolve via resolveId
+            type PathMapping = { prefix: string; replacement: string; wildcard: boolean }
+            let mappings: PathMapping[] = []
+
+            function loadMappings(resolvedRoot: string) {
+              try {
+                const configPath = path.resolve(resolvedRoot, 'tsconfig.json')
+                if (!existsSync(configPath)) return
+                const raw = readFileSync(configPath, 'utf-8')
+                // strip single-line and multi-line comments for JSON.parse
+                const stripped = raw.replace(
+                  /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
+                  (m, g) => (g ? '' : m)
+                )
+                const config = JSON.parse(stripped)
+                const paths = config?.compilerOptions?.paths
+                const baseUrl = config?.compilerOptions?.baseUrl || '.'
+                if (!paths) return
+                for (const [pattern, targets] of Object.entries(
+                  paths as Record<string, string[]>
+                )) {
+                  const target = targets[0]
+                  if (!target) continue
+                  if (pattern.endsWith('/*')) {
+                    const resolved = path.resolve(
+                      resolvedRoot,
+                      baseUrl,
+                      target.slice(0, -1)
+                    )
+                    mappings.push({
+                      prefix: pattern.slice(0, -1),
+                      replacement: resolved.endsWith('/') ? resolved : resolved + '/',
+                      wildcard: true,
+                    })
+                  } else {
+                    mappings.push({
+                      prefix: pattern,
+                      replacement: path.resolve(resolvedRoot, baseUrl, target),
+                      wildcard: false,
+                    })
+                  }
+                }
+              } catch {}
             }
 
-            const tsPathsPlugin = tsconfigPaths({
-              projectDiscovery: 'eager',
-              ignoreConfigErrors: true,
-              skip: skipDotDirs,
-              ...(pathsConfig && typeof pathsConfig === 'object' ? pathsConfig : {}),
-            })
-
             return {
-              ...tsPathsPlugin,
-              // let vite aliases (e.g. react-native → react-native-web) resolve first
-              enforce: undefined,
-              // parallel viteBuild() calls share this plugin, so the second
-              // build's buildStart can fire before configResolved initializes
-              // tsconfigResolvers — swallow the error since buildStart only
-              // resets caches which isn't needed for parallel builds
-              buildStart() {
-                try {
-                  return tsPathsPlugin.buildStart?.call(this)
-                } catch {}
+              name: 'one:tsconfig-paths',
+              enforce: 'pre',
+
+              config() {
+                return {
+                  resolve: { tsconfigPaths: true },
+                }
               },
-            }
+
+              configResolved(config) {
+                if (mappings.length === 0) {
+                  loadMappings(config.root)
+                }
+              },
+
+              resolveId(source: string) {
+                const jsExts = [
+                  '.ts',
+                  '.tsx',
+                  '.js',
+                  '.jsx',
+                  '.mts',
+                  '.mjs',
+                  '.cjs',
+                  '.cts',
+                ]
+                for (const m of mappings) {
+                  let candidate: string | undefined
+                  if (m.wildcard) {
+                    if (source.startsWith(m.prefix)) {
+                      candidate = m.replacement + source.slice(m.prefix.length)
+                    }
+                  } else if (source === m.prefix) {
+                    candidate = m.replacement
+                  }
+                  if (!candidate) continue
+                  // already has a js/ts extension
+                  if (jsExts.includes(path.extname(candidate))) return candidate
+                  // try appending extensions
+                  for (const e of jsExts) {
+                    if (existsSync(candidate + e)) return candidate + e
+                  }
+                  // try /index
+                  for (const e of jsExts) {
+                    if (existsSync(candidate + '/index' + e))
+                      return candidate + '/index' + e
+                  }
+                  return candidate
+                }
+              },
+            } satisfies Plugin
           })(),
         ]),
 
+    {
+      // rolldown fails on deep react-native/Libraries/* imports during dep pre-bundling.
+      // these are native-only paths that don't exist in react-native-web.
+      name: 'one:redirect-rn-deep-imports',
+      enforce: 'pre',
+
+      resolveId(source) {
+        if (this.environment?.name === 'client' || this.environment?.name === 'ssr') {
+          if (
+            source.startsWith('react-native/Libraries/') ||
+            /react-native-web(-lite)?\/.*\/Libraries\//.test(source)
+          ) {
+            return '\0rn-empty-module'
+          }
+        }
+      },
+
+      load(id) {
+        if (id === '\0rn-empty-module') {
+          return 'export default {}; export {};'
+        }
+      },
+    } satisfies Plugin,
+
     {
       name: 'one-aliases',
       enforce: 'pre',
@@ -520,9 +618,19 @@ export function one(options: One.PluginOptions = {}): PluginOption {
       options.router?.experimental?.preventLayoutRemounting,
   }
 
+  // source inspector must come before clientTreeShakePlugin so line numbers
+  // are computed from original source (tree-shaking removes loader code, shifting lines)
+  const inspectorPlugins = (() => {
+    const devtools = options.devtools ?? true
+    const inspector =
+      devtools === true || (devtools !== false && (devtools.inspector ?? true))
+    return inspector ? sourceInspectorPlugin() : []
+  })()
+
   return [
     ...vxrnPlugins,
     ...devAndProdPlugins,
+    ...inspectorPlugins,
     ...nativeWebDevAndProdPlugsin,
 
     /**
@@ -532,7 +640,7 @@ export function one(options: One.PluginOptions = {}): PluginOption {
 
     generateFileSystemRouteTypesPlugin(options),
 
-    fixDependenciesPlugin(options.deps),
+    fixDependenciesPlugin(options.patches),
 
     createVirtualEntry({
       ...options,
@@ -565,13 +673,11 @@ export function one(options: One.PluginOptions = {}): PluginOption {
     ...(() => {
       const devtools = options.devtools ?? true
       const includeUI = devtools !== false
-      const inspector =
-        devtools === true || (devtools !== false && (devtools.inspector ?? true))
       return [
         // always include devtools plugin for refresh preamble (required for HMR)
         createDevtoolsPlugin({ includeUI }),
-        ...(inspector ? sourceInspectorPlugin() : []),
       ]
     })(),
   ]
 }
+// vite 8

package/src/vite/plugins/SSRCSSPlugin.ts

@@ -118,7 +118,7 @@ export async function collectStyle(server: ViteDevServer, entries: string[]) {
           filename: 'code.css',
           code: codeOut,
           ...server.config.css.lightningcss,
-        }).code.toString()
+        } as any).code.toString()
 
         return [prefix, processed]
       } catch (err) {
@@ -138,7 +138,7 @@ export async function collectStyle(server: ViteDevServer, entries: string[]) {
       filename: 'code.css',
       code: codeOut,
       ...server.config.css.lightningcss,
-    }).code.toString()
+    } as any).code.toString()
   } catch (err) {
     console.error(` [one] Error post-processing merged CSS, leaving un-processed`)
   }

package/src/vite/plugins/criticalCSSPlugin.test.ts

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+describe('criticalCSSPlugin', () => {
+  beforeEach(() => {
+    vi.resetModules()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('resolveId', () => {
+    it('should return null for non-inline CSS imports', async () => {
+      const { criticalCSSPlugin } = await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+
+      ;(plugin.configResolved as any)({ root: '/project' })
+
+      const result = await (plugin.resolveId as any).call(
+        { resolve: vi.fn() },
+        './styles.css',
+        '/project/src/App.tsx'
+      )
+      expect(result).toBeNull()
+    })
+
+    it('should return null for non-css imports', async () => {
+      const { criticalCSSPlugin } = await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+
+      ;(plugin.configResolved as any)({ root: '/project' })
+
+      const result = await (plugin.resolveId as any).call(
+        { resolve: vi.fn() },
+        './data.json',
+        '/project/src/App.tsx'
+      )
+      expect(result).toBeNull()
+    })
+
+    it('should resolve .inline.css and track it', async () => {
+      const { criticalCSSPlugin } = await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+
+      ;(plugin.configResolved as any)({ root: '/project' })
+
+      const mockResolve = vi.fn().mockResolvedValue({
+        id: '/project/src/styles.inline.css',
+      })
+
+      const result = await (plugin.resolveId as any).call(
+        { resolve: mockResolve },
+        './styles.inline.css',
+        '/project/src/App.tsx'
+      )
+
+      expect(mockResolve).toHaveBeenCalledWith(
+        './styles.inline.css',
+        '/project/src/App.tsx',
+        { skipSelf: true }
+      )
+
+      expect(result).toEqual({ id: '/project/src/styles.inline.css' })
+    })
+
+    it('should track inline CSS source paths', async () => {
+      const { criticalCSSPlugin, getCriticalCSSSources } =
+        await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+
+      ;(plugin.configResolved as any)({ root: '/project' })
+
+      const mockResolve = vi.fn().mockResolvedValue({
+        id: '/project/src/layout.inline.css',
+      })
+
+      await (plugin.resolveId as any).call(
+        { resolve: mockResolve },
+        './layout.inline.css',
+        '/project/src/App.tsx'
+      )
+
+      const sources = getCriticalCSSSources()
+      expect(sources.has('src/layout.inline.css')).toBe(true)
+    })
+
+    it('should return null when resolve fails', async () => {
+      const { criticalCSSPlugin } = await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+
+      ;(plugin.configResolved as any)({ root: '/project' })
+
+      const mockResolve = vi.fn().mockResolvedValue(null)
+
+      const result = await (plugin.resolveId as any).call(
+        { resolve: mockResolve },
+        './nonexistent.inline.css',
+        '/project/src/App.tsx'
+      )
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('getCriticalCSSOutputPaths', () => {
+    it('should map inline CSS source to output paths via manifest', async () => {
+      const { criticalCSSPlugin, getCriticalCSSSources, getCriticalCSSOutputPaths } =
+        await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+
+      ;(plugin.configResolved as any)({ root: '/project' })
+
+      const mockResolve = vi.fn().mockResolvedValue({
+        id: '/project/app/layout.inline.css',
+      })
+      await (plugin.resolveId as any).call(
+        { resolve: mockResolve },
+        './layout.inline.css',
+        '/project/app/_layout.tsx'
+      )
+
+      const manifest = {
+        'app/layout.inline.css': {
+          file: 'assets/layout-abc123.css',
+          src: 'app/layout.inline.css',
+        },
+        'app/_layout.tsx': {
+          file: 'assets/layout-def456.js',
+          css: ['assets/layout-abc123.css'],
+          imports: [],
+          name: '_layout',
+        },
+      }
+
+      const outputPaths = getCriticalCSSOutputPaths(manifest as any)
+      expect(outputPaths.has('/assets/layout-abc123.css')).toBe(true)
+    })
+
+    it('should return empty set when no inline CSS exists', async () => {
+      const { getCriticalCSSOutputPaths } = await import('./criticalCSSPlugin')
+
+      const manifest = {
+        'app/styles.css': {
+          file: 'assets/styles-abc.css',
+        },
+      }
+
+      const outputPaths = getCriticalCSSOutputPaths(manifest as any)
+      expect(outputPaths).toBeDefined()
+    })
+  })
+
+  describe('plugin metadata', () => {
+    it('should have correct name', async () => {
+      const { criticalCSSPlugin } = await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+      expect(plugin.name).toBe('one:critical-css')
+    })
+
+    it('should enforce pre', async () => {
+      const { criticalCSSPlugin } = await import('./criticalCSSPlugin')
+      const plugin = criticalCSSPlugin()
+      expect(plugin.enforce).toBe('pre')
+    })
+  })
+})