one 2.10.0 → 2.11.1

package/src/vite/one.ts

@@ -31,17 +31,20 @@ import { createDevtoolsPlugin } from './plugins/devtoolsPlugin'
 import { createFileSystemRouterPlugin } from './plugins/fileSystemRouterPlugin'
 import { fixDependenciesPlugin } from './plugins/fixDependenciesPlugin'
 import { generateFileSystemRouteTypesPlugin } from './plugins/generateFileSystemRouteTypesPlugin'
+import { loaderSearchSchemasPlugin } from './plugins/loaderSearchSchemasPlugin'
 import { criticalCSSPlugin } from './plugins/criticalCSSPlugin'
 import { imageDataPlugin } from './plugins/imageDataPlugin'
 import { createRouteModuleHmrPlugin } from './plugins/routeModuleHmrPlugin'
 import { sourceInspectorPlugin } from './plugins/sourceInspectorPlugin'
 import { swiftPackagePlugin } from './plugins/swiftPackagePlugin'
+import { iosLinkSetPlugin } from './plugins/iosLinkSetPlugin'
 import { iosSdkPlugin } from './plugins/iosSdkPlugin'
 import { kotlinSourcePlugin } from './plugins/kotlinSourcePlugin'
 import { SSRCSSPlugin } from './plugins/SSRCSSPlugin'
 import { virtualEntryId } from './plugins/virtualEntryConstants'
 import { createVirtualEntry } from './plugins/virtualEntryPlugin'
 import { environmentGuardPlugin } from './plugins/environmentGuardPlugin'
+import { useDOMPlugin } from './plugins/useDomPlugin'
 import { shouldEnableWorkerdDev } from './cloudflareWranglerConfig'
 import type { One } from './types'
 
@@ -319,7 +322,7 @@ export function one(options: One.PluginOptions = {}): PluginOption {
   // native bundler, which has no vite environment and so is told its platform
   const createAliasPlugin = (
     alias: NonNullable<One.PluginOptions['alias']>,
-    nativePlatform?: 'ios' | 'android'
+    nativePlatform?: 'ios' | 'android' | 'macos' | 'linux'
   ) => {
     const resolveMap = (map?: Record<string, string>) => {
       if (!map) return null
@@ -400,7 +403,19 @@ export function one(options: One.PluginOptions = {}): PluginOption {
     } satisfies Plugin
   }
 
+  const domPlugin = useDOMPlugin({
+    root,
+    routerRoot,
+    ignoredRouteFiles: options.router?.ignoredRouteFiles,
+    metro: !!metroOptions,
+    browserPlugins: [
+      createAliasPlugin(withAbsorbedAliases(options.alias)),
+      environmentGuardPlugin(options.environmentGuards),
+    ],
+  })
+
   const devAndProdPlugins: Plugin[] = [
+    domPlugin,
     {
       name: 'one:config',
       __get: options,
@@ -785,6 +800,26 @@ export function one(options: One.PluginOptions = {}): PluginOption {
                 }),
               },
             },
+            macos: {
+              define: {
+                ...getPlatformEnvDefine('macos'),
+                ...(nativeOptions?.suspendRoutes !== undefined && {
+                  'process.env.ONE_SUSPEND_ROUTES_NATIVE': JSON.stringify(
+                    nativeOptions.suspendRoutes ? '1' : '0'
+                  ),
+                }),
+              },
+            },
+            linux: {
+              define: {
+                ...getPlatformEnvDefine('linux'),
+                ...(nativeOptions?.suspendRoutes !== undefined && {
+                  'process.env.ONE_SUSPEND_ROUTES_NATIVE': JSON.stringify(
+                    nativeOptions.suspendRoutes ? '1' : '0'
+                  ),
+                }),
+              },
+            },
           },
 
           ssr: {
@@ -821,6 +856,16 @@ export function one(options: One.PluginOptions = {}): PluginOption {
                 'process.env.TAMAGUI_KEEP_THEMES': '"1"',
               },
             },
+            macos: {
+              define: {
+                'process.env.TAMAGUI_KEEP_THEMES': '"1"',
+              },
+            },
+            linux: {
+              define: {
+                'process.env.TAMAGUI_KEEP_THEMES': '"1"',
+              },
+            },
           },
         }
       },
@@ -923,18 +968,26 @@ export function one(options: One.PluginOptions = {}): PluginOption {
         ? undefined
         : (nativeOptions?.bundlerOptions as any)
 
-    globalThis.__vxrnAddNativePlugins = (platform: 'ios' | 'android') => {
+    globalThis.__vxrnAddNativePlugins = (platform: 'ios' | 'android' | 'macos' | 'linux') => {
       const listed: Plugin[] = [
+        domPlugin,
         backgroundComputationPlugin('native'),
         workletImportsPlugin({}),
         ...(nativeApp
           ? [
               {
                 name: 'one:externalize-expo-for-native-app',
-                resolveId(source) {
+                resolveId(source, _importer, options) {
                   // native.app binaries have no expo runtime, even when the
                   // workspace hoists an expo package used by another app.
                   if (/^(?:expo(?:-[^/]+)?|@expo\/[^/]+)(?:\/|$)/.test(source)) {
+                    // macos and linux must resolve static imports so unsupported packages fail
+                    // during bundling. optional require calls still use the runtime guard.
+                    if (
+                      (platform === 'macos' || platform === 'linux') &&
+                      options.kind !== 'require-call'
+                    )
+                      return
                     return { id: source, external: true }
                   }
                 },
@@ -953,6 +1006,7 @@ export function one(options: One.PluginOptions = {}): PluginOption {
         swiftPackagePlugin(platform, root),
         kotlinSourcePlugin(platform, root),
         iosSdkPlugin(platform, root),
+        iosLinkSetPlugin(),
       ]
     }
     ;(globalThis as any).__vxrnNativeUserDefine = {
@@ -1027,6 +1081,8 @@ export function one(options: One.PluginOptions = {}): PluginOption {
 
     generateFileSystemRouteTypesPlugin(options, routeIndex),
 
+    loaderSearchSchemasPlugin(options, routeIndex),
+
     fixDependenciesPlugin(options.patches),
 
     createVirtualEntry({

package/src/vite/plugins/clientTreeShakePlugin.ts

@@ -22,7 +22,13 @@ export const clientTreeShakePlugin = (opts?: {
 
     ...(runtime === 'vite' && {
       applyToEnvironment(env: { name: string }) {
-        return env.name === 'client' || env.name === 'ios' || env.name === 'android'
+        return (
+          env.name === 'client' ||
+          env.name === 'ios' ||
+          env.name === 'android' ||
+          env.name === 'macos' ||
+          env.name === 'linux'
+        )
       },
     }),
 

package/src/vite/plugins/environmentGuardPlugin.ts

@@ -9,8 +9,8 @@
  * |-----------------|------------------|----------------------------|
  * | server-only     | any server env   | any client env             |
  * | client-only     | any client env   | any server env             |
- * | native-only     | ios, android     | other names                |
- * | web-only        | client, ssr      | ios, android               |
+ * | native-only     | ios, android, macos, linux | other names      |
+ * | web-only        | client, ssr      | ios, android, macos, linux |
  *
  * server-only / client-only key off `env.config.consumer` so they work
  * uniformly across `ssr`, custom names like `worker` (cloudflare deploy),
@@ -35,10 +35,10 @@ const GUARD_SPECIFIERS = [
 const GUARD_SPECIFIERS_RE = new RegExp(`^(?:${GUARD_SPECIFIERS.join('|')})$`)
 
 type GuardSpecifier = (typeof GUARD_SPECIFIERS)[number]
-type ViteEnvironment = 'client' | 'ssr' | 'ios' | 'android' | 'worker'
+type ViteEnvironment = 'client' | 'ssr' | 'ios' | 'android' | 'macos' | 'linux' | 'worker'
 
 const ALLOWED_BY_NAME: Partial<Record<GuardSpecifier, readonly ViteEnvironment[]>> = {
-  'native-only': ['ios', 'android'],
+  'native-only': ['ios', 'android', 'macos', 'linux'],
   'web-only': ['client', 'ssr', 'worker'],
 }
 

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

@@ -363,4 +363,55 @@ describe('createFileSystemRouterPlugin', () => {
     }
     expect(loader).toHaveBeenCalledTimes(24)
   })
+
+  it('escapes route entries for optimizeDeps glob', async () => {
+    process.env.IS_VXRN_CLI = '1'
+    tempRoot = mkdtempSync(path.join(tmpdir(), 'one-router-entries-'))
+    const root = tempRoot
+    const appDir = path.join(tempRoot, 'app')
+    writeFileSync(path.join(tempRoot, 'package.json'), '{}\n')
+    for (const f of ['index.tsx', '(tabs)/feed.tsx', 'docs/[slug]+ssg.tsx']) {
+      const full = path.join(appDir, f)
+      mkdirSync(path.dirname(full), { recursive: true })
+      writeFileSync(full, 'export default function X() { return null }\n')
+    }
+
+    ;(globalThis as any).__vxrnPluginConfig__ = {
+      web: {
+        defaultRenderMode: 'ssg',
+      },
+    }
+
+    const { createRouteIndex } = await import('../../utils/routeIndex')
+    const { createFileSystemRouterPlugin } = await import('./fileSystemRouterPlugin')
+    const plugin = createFileSystemRouterPlugin(
+      {
+        router: { root: 'app' },
+        optimization: { autoEntriesScanning: true },
+      },
+      createRouteIndex({ routerRoot: appDir })
+    )
+
+    // neighbor on disk after manifest freeze: never an entry, must stay excluded
+    const neighbor = path.join(appDir, 'tabs', 'feed.tsx')
+    mkdirSync(path.dirname(neighbor), { recursive: true })
+    writeFileSync(neighbor, 'export default function N() { return null }\n')
+
+    const cfg = (await (plugin as any).config()) as
+      | { optimizeDeps?: { entries?: string[] } }
+      | undefined
+    const entries = cfg?.optimizeDeps?.entries
+    expect(entries).toBeDefined()
+
+    const { default: fastGlob } = await import('fast-glob')
+    const globbed = fastGlob.sync(entries!, {
+      absolute: true,
+      cwd: tempRoot,
+      ignore: ['**/node_modules/**'],
+    })
+    const expected = ['app/index.tsx', 'app/(tabs)/feed.tsx', 'app/docs/[slug]+ssg.tsx']
+      .map((f) => path.join(root, f))
+      .sort()
+    expect([...globbed].sort()).toEqual(expected)
+  })
 })

package/src/vite/plugins/fileSystemRouterPlugin.tsx

@@ -1,6 +1,7 @@
 import path from 'node:path'
 import { Readable } from 'node:stream'
 import { TLSSocket } from 'node:tls'
+import fastGlob from 'fast-glob'
 import { debounce } from 'perfect-debounce'
 import colors from 'picocolors'
 import type { Connect, Plugin, ViteDevServer } from 'vite'
@@ -16,6 +17,11 @@ import { isResponse } from '../../utils/isResponse'
 import { isStatusRedirect } from '../../utils/isStatus'
 import { promiseWithResolvers } from '../../utils/promiseWithResolvers'
 import type { RouteIndex } from '../../utils/routeIndex'
+import {
+  getLoaderSearchSchemas,
+  withLoaderSearchParams,
+  type LoaderSearchSchemas,
+} from '../../loaderSearchParams'
 import { isRouteFileWatchEvent } from '../../utils/routeFileWatch'
 import { trackLoaderDependencies } from '../../utils/trackLoaderDependencies'
 import type { One, RouteInfo } from '../../vite/types'
@@ -216,7 +222,9 @@ export function createFileSystemRouterPlugin(
             // helper to run a loader and track dependencies
             async function runLoaderWithTracking(
               routeNode: RouteNode | { contextKey: string; file?: string },
-              loaderFn: ((props: any) => any) | undefined
+              loaderFn: ((props: any) => any) | undefined,
+              // only ssr document requests carry the query a loader can validate
+              searchSchemas?: LoaderSearchSchemas | null
             ): Promise<{ loaderData: any; routeId: string; isEnoent?: boolean }> {
               const routeId = routeNode.contextKey
               if (!loaderFn) {
@@ -224,10 +232,14 @@ export function createFileSystemRouterPlugin(
               }
 
               try {
-                const tracked = await trackLoaderDependencies(() => loaderFn(loaderProps))
+                const props = searchSchemas
+                  ? withLoaderSearchParams(searchSchemas, loaderProps)
+                  : loaderProps
+                const tracked = await trackLoaderDependencies(() => loaderFn(props))
 
                 // register dependencies for HMR
-                const routePath = loaderProps?.path || '/'
+                // an ssr route's data depends on its query, which hot reload refetches by
+                const routePath = (loaderProps?.path || '/') + (route.type === 'ssr' ? (loaderProps?.search ?? '') : '')
                 for (const dep of tracked.dependencies) {
                   const absoluteDep = path.resolve(dep)
                   setBoundedLoaderDep(absoluteDep, routePath)
@@ -284,11 +296,19 @@ export function createFileSystemRouterPlugin(
               const layoutLoaderPromises = layoutRoutes.map(async (layout) => {
                 const layoutFile = path.join(routerRoot, layout.contextKey)
                 const layoutExported = await runner.import(layoutFile)
-                return runLoaderWithTracking(layout, layoutExported.loader)
+                return runLoaderWithTracking(
+                  layout,
+                  layoutExported.loader,
+                  route.type === 'ssr' ? getLoaderSearchSchemas(layoutExported) : null
+                )
               })
 
               // run page loader
-              const pageLoaderPromise = runLoaderWithTracking(pageRoute, exported.loader)
+              const pageLoaderPromise = runLoaderWithTracking(
+                pageRoute,
+                exported.loader,
+                route.type === 'ssr' ? getLoaderSearchSchemas(exported) : null
+              )
 
               // wait for all loaders in parallel
               let layoutResults: Awaited<ReturnType<typeof runLoaderWithTracking>>[]
@@ -538,8 +558,14 @@ export function createFileSystemRouterPlugin(
           let loaderData: any
           if (exported.loader) {
             try {
+              // a client navigation to an ssr route validates its query like the document request
+              const searchSchemas =
+                route.type === 'ssr' ? getLoaderSearchSchemas(exported) : null
+              const runProps = searchSchemas
+                ? withLoaderSearchParams(searchSchemas, loaderProps)
+                : loaderProps
               const tracked = await trackLoaderDependencies(() =>
-                exported.loader(loaderProps)
+                exported.loader(runProps)
               )
               loaderData = tracked.result
 
@@ -551,7 +577,8 @@ export function createFileSystemRouterPlugin(
               }
 
               // Register dependencies: map file path -> route paths that depend on it
-              const routePath = loaderProps?.path || '/'
+              // an ssr route's data depends on its query, which hot reload refetches by
+                const routePath = (loaderProps?.path || '/') + (route.type === 'ssr' ? (loaderProps?.search ?? '') : '')
               for (const dep of tracked.dependencies) {
                 // Resolve to absolute path for consistent lookup when file changes
                 const absoluteDep = path.resolve(dep)
@@ -668,12 +695,18 @@ export function createFileSystemRouterPlugin(
                 return []
               }
 
-              // optimizeDeps.entries uses tinyglobby — needs forward-slash patterns
+              // optimizeDeps.entries uses tinyglobby — needs forward-slash patterns.
+              // entries are literal route files, so escape glob magic: (group)
+              // and [param] segments would otherwise drop or overmatch.
               return [
-                path.posix.join(`./${routerRoot}`, route.file),
+                fastGlob.escapePath(path.posix.join(`./${routerRoot}`, route.file)),
                 ...(route.layouts?.flatMap((layout) => {
                   if (!layout.contextKey) return []
-                  return [path.posix.join(`./${routerRoot}`, layout.contextKey)]
+                  return [
+                    fastGlob.escapePath(
+                      path.posix.join(`./${routerRoot}`, layout.contextKey)
+                    ),
+                  ]
                 }) || []),
               ]
             })

package/src/vite/plugins/generateFileSystemRouteTypesPlugin.tsx

@@ -26,9 +26,12 @@ export function generateFileSystemRouteTypesPlugin(
       const typedRoutesGeneration =
         options.router?.experimental?.typedRoutesGeneration || undefined
 
+      // files read to find component search schemas, a change to one can change the types
+      let searchSchemaFiles = new Set<string>()
+
       // on change ./app stuff lets reload this to pick up any route changes
       const generateRouteTypesDebounced = debounce(async () => {
-        await generateRouteTypes(
+        searchSchemaFiles = await generateRouteTypes(
           outFile,
           routerRoot,
           options.router?.ignoredRouteFiles,
@@ -48,6 +51,9 @@ export function generateFileSystemRouteTypesPlugin(
           routeIndex.update(type, path)
           return generateRouteTypesDebounced()
         }
+        if (searchSchemaFiles.has(resolve(path))) {
+          return generateRouteTypesDebounced()
+        }
       }
 
       server.watcher.addListener('all', fileWatcherChangeListener)
@@ -61,7 +67,9 @@ export function generateFileSystemRouteTypesPlugin(
           options.router?.ignoredRouteFiles,
           typedRoutesGeneration,
           routeIndex.getPaths()
-        )
+        ).then((files) => {
+          searchSchemaFiles = files
+        })
       }
     },
   } satisfies Plugin

package/src/vite/plugins/iosLinkSetPlugin.ts

@@ -0,0 +1,64 @@
+import { realpathSync, writeFileSync } from 'node:fs'
+import type { Plugin } from 'vite'
+import {
+  IOS_LINK_SET_REPORT_ENV,
+  assertLinkSet,
+  oneDirectory,
+  readCatalog,
+} from '../../cli/iosLinkSet'
+import {
+  analyzeModule,
+  catalogNames,
+  emptyUsage,
+  groupsForUsage,
+  keyPattern,
+  mightUseGroups,
+} from '../../cli/iosLinkSetAnalysis'
+
+// reads every module of the production ios bundle for the features of the iOS link
+// set it uses, from the bundler's own module graph so third-party packages count.
+// prebuild asks for the groups through a report file. a release xcode build checks
+// them against the groups the pod compiled and fails when the binary lacks one.
+export function iosLinkSetPlugin(): Plugin {
+  return {
+    name: 'one:ios-link-set',
+    api: {
+      // the analysis runs only on the production ios bundle
+      vxrnNative: (context: { platform: string; dev: boolean }): Plugin =>
+        context.platform === 'ios' && !context.dev ? analysisPlugin() : { name: 'one:ios-link-set' },
+    },
+  }
+}
+
+function analysisPlugin(): Plugin {
+  const catalog = readCatalog()
+  const { keys } = catalogNames(catalog)
+  const keySet = new Set(keys.keys())
+  const pattern = keyPattern(keySet)
+  const own = [oneDirectory()]
+  try {
+    own.push(realpathSync(own[0]))
+  } catch {}
+  const usage = emptyUsage()
+
+  return {
+    name: 'one:ios-link-set',
+    transform: {
+      order: 'pre',
+      handler(code, id) {
+        const file = id.split('?')[0]
+        if (file.startsWith('\0') || file.startsWith('virtual:')) return
+        if (own.some((dir) => file.startsWith(dir + '/'))) return
+        if (!mightUseGroups(code, keySet, pattern)) return
+        analyzeModule(code, file, keySet, usage)
+      },
+    },
+    buildEnd(error) {
+      if (error) return
+      const groups = groupsForUsage(usage, catalog)
+      const report = process.env[IOS_LINK_SET_REPORT_ENV]
+      if (report) writeFileSync(report, JSON.stringify({ groups }) + '\n')
+      assertLinkSet(groups)
+    },
+  }
+}

package/src/vite/plugins/iosSdkPlugin.ts

@@ -4,7 +4,10 @@ import { resolveIosSdkImport } from '../../utils/iosSdkFacade'
 // `one/ios/<Framework>` is the generated typescript facade over that
 // framework's native table. One ships the facades; native prebuild uses the
 // same generator ABI and signature-based entry ids on the builder's SDK.
-export function iosSdkPlugin(platform: 'ios' | 'android', root: string): Plugin {
+export function iosSdkPlugin(
+  platform: 'ios' | 'android' | 'macos' | 'linux',
+  root: string
+): Plugin {
   return {
     name: 'one:ios-sdk',
     resolveId: {

package/src/vite/plugins/kotlinSourcePlugin.ts

@@ -3,7 +3,10 @@ import { renderKotlinSourceModule } from './kotlinSourceModule'
 
 // the contract parser loads on the first .kt import, so an app without one
 // never evaluates it.
-export function kotlinSourcePlugin(platform: 'ios' | 'android', root: string): Plugin {
+export function kotlinSourcePlugin(
+  platform: 'ios' | 'android' | 'macos' | 'linux',
+  root: string
+): Plugin {
   return {
     name: 'one:kotlin-source',
     load: {

package/src/vite/plugins/loaderSearchSchemasPlugin.ts

@@ -0,0 +1,69 @@
+import { join, relative, resolve } from 'node:path'
+import type { Plugin } from 'vite'
+import { getSearchSchemaEntries } from '../../typed-routes/searchSchemaEntries'
+import { createSearchSchemaScanner } from '../../typed-routes/searchParamSchemas'
+import { getRouterRootFromOneOptions } from '../../utils/getRouterRootFromOneOptions'
+import type { RouteIndex } from '../../utils/routeIndex'
+import type { One } from '../types'
+
+/**
+ * Hands the search schemas that components pass to `useSearchParams(schema)` to the
+ * loader of the route they render under, so the server validates the query before
+ * the loader runs.
+ *
+ * Only server builds are touched. A route module that exports a loader and has
+ * schemas in its route or layouts gets an `__oneSearchSchemas` export, a list of
+ * functions that read each schema. A module with no schemas is left as it is.
+ */
+export function loaderSearchSchemasPlugin(
+  options: One.PluginOptions,
+  routeIndex: RouteIndex
+): Plugin {
+  const routerRoot = resolve(process.cwd(), getRouterRootFromOneOptions(options))
+
+  return {
+    name: 'one:loader-search-schemas',
+    enforce: 'post',
+
+    applyToEnvironment(environment) {
+      return environment.config.consumer === 'server'
+    },
+
+    transform(code, id) {
+      const file = id.split('?')[0]
+      if (!file.startsWith(routerRoot) || !/\bloader\b/.test(code)) return
+
+      const contextKey = `./${relative(routerRoot, file).replaceAll('\\', '/')}`
+      const routePaths = routeIndex.getPaths()
+      if (!routePaths.includes(contextKey)) return
+
+      // a new scanner each time, so an edit to any scanned file is read again
+      const { scan, exportsLoader } = createSearchSchemaScanner(process.cwd())
+      if (!exportsLoader(file)) return
+
+      const result = scan(
+        getSearchSchemaEntries(routePaths, contextKey).map((key) => join(routerRoot, key))
+      )
+      // an edit to any of these can change which schemas the loader sees
+      for (const scanned of result.files) this.addWatchFile(scanned)
+      if (!result.schemas.length) return
+
+      let imports = ''
+      const reads: string[] = []
+      for (const ref of result.schemas) {
+        if (ref.module === file && ref.local) {
+          reads.push(`() => ${ref.local}`)
+          continue
+        }
+        const namespace = `__oneSearchModule${reads.length}`
+        imports += `import * as ${namespace} from ${JSON.stringify(ref.module)};\n`
+        reads.push(`() => ${namespace}[${JSON.stringify(ref.name)}]`)
+      }
+
+      return {
+        code: `${code}\n${imports}export const __oneSearchSchemas = [${reads.join(', ')}];\n`,
+        map: null,
+      }
+    },
+  }
+}

package/src/vite/plugins/swiftPackagePlugin.ts

@@ -7,7 +7,10 @@ import { renderSwiftPackageModule } from './swiftPackageModule'
 // file whose @main type is an App is a whole swift app, so its root fills the
 // screen instead of sizing to its content. the contract parser loads on the
 // first .swift import, so an app without one never evaluates it.
-export function swiftPackagePlugin(platform: 'ios' | 'android', root: string): Plugin {
+export function swiftPackagePlugin(
+  platform: 'ios' | 'android' | 'macos' | 'linux',
+  root: string
+): Plugin {
   return {
     name: 'one:swift-package',
     load: {