one 1.15.10 → 1.16.0

package/src/cli/build.ts

@@ -5,7 +5,13 @@ import { resolvePath } from '@vxrn/resolve'
 import FSExtra from 'fs-extra'
 import MicroMatch from 'micromatch'
 import type { OutputAsset, RolldownOutput } from 'rolldown'
-import { type InlineConfig, mergeConfig, build as viteBuild } from 'vite'
+import {
+  createBuilder,
+  type InlineConfig,
+  mergeConfig,
+  normalizePath,
+  build as viteBuild,
+} from 'vite'
 import {
   type ClientManifestEntry,
   fillOptions,
@@ -19,7 +25,7 @@ import { setServerGlobals } from '../server/setServerGlobals'
 import { getPathnameFromFilePath } from '../utils/getPathnameFromFilePath'
 import { getRouterRootFromOneOptions } from '../utils/getRouterRootFromOneOptions'
 import { isRolldown } from '../utils/isRolldown'
-import { toAbsolute } from '../utils/toAbsolute'
+import { toAbsolute, toAbsoluteUrl } from '../utils/toAbsolute'
 import { buildVercelOutputDirectory } from '../vercel/build/buildVercelOutputDirectory'
 import { getManifest } from '../vite/getManifest'
 import { loadUserOneOptions } from '../vite/loadConfig'
@@ -380,24 +386,59 @@ export async function build(args: {
   const { optimizeDeps } = getOptimizeDeps('build')
   const { rolldownOptions: _rolldownOptions, ...optimizeDepsNoRolldown } = optimizeDeps
 
+  // unified mode: api + middleware routes share config with the SSR server build —
+  // same defines, plugins, externalization rules, no blanket noExternal: true.
+  // when off, keep the legacy path that derives from webBuildConfig with
+  // ssr.noExternal: true hard-coded (back-compat).
+  const serverOpts = oneOptions.build?.server
+  const isUnified =
+    typeof serverOpts === 'object' && serverOpts !== null && serverOpts.unified === true
+
   // clone plugin hooks so vite's wrapHookObject doesn't fail on reuse across builds
   // (vite defines non-configurable getters on hook objects during the first build)
-  const clonedWebBuildConfig = clonePluginHooks(vxrnOutput.webBuildConfig)
+  let baseForApi = isUnified
+    ? clonePluginHooks(vxrnOutput.serverBuildConfig ?? vxrnOutput.webBuildConfig)
+    : clonePluginHooks(vxrnOutput.webBuildConfig)
+
+  if (isUnified) {
+    // serverBuildConfig has rolldownOptions.input: ['virtual:one-entry'] —
+    // vite mergeConfig concatenates that with the api build's input object,
+    // which rolldown then tries to iterate as a string list. strip it so the
+    // per-routes input map in buildCustomRoutes takes effect cleanly.
+    //
+    // also strip `omit-api-routes`, the server's transform plugin that empties
+    // any +api / _middleware file. correct for the SSR render bundle, wrong
+    // for api/middleware builds where those files ARE the entry points.
+    const clone: InlineConfig = {
+      ...baseForApi,
+      build: baseForApi.build ? { ...baseForApi.build } : undefined,
+      plugins: baseForApi.plugins
+        ? (baseForApi.plugins as any[]).filter(
+            (p) => p && typeof p === 'object' && p.name !== 'omit-api-routes'
+          )
+        : undefined,
+    }
+    if (clone.build && (clone.build as any).rolldownOptions) {
+      const ro = { ...((clone.build as any).rolldownOptions as any) }
+      delete ro.input
+      ;(clone.build as any).rolldownOptions = ro
+    }
+    if (clone.build) {
+      delete (clone.build as any).outDir
+    }
+    baseForApi = clone
+  }
 
-  const apiBuildConfig = mergeConfig(
-    // feels like this should build off the *server* build config not web
-    clonedWebBuildConfig,
-    {
-      configFile: false,
-      appType: 'custom',
-      optimizeDeps: optimizeDepsNoRolldown,
-      environments: {
-        client: {
-          optimizeDeps: { rolldownOptions: _rolldownOptions },
-        },
+  const apiBuildConfig = mergeConfig(baseForApi, {
+    configFile: false,
+    appType: 'custom',
+    optimizeDeps: optimizeDepsNoRolldown,
+    environments: {
+      client: {
+        optimizeDeps: { rolldownOptions: _rolldownOptions },
       },
-    } satisfies InlineConfig
-  )
+    },
+  } satisfies InlineConfig)
 
   async function buildCustomRoutes(subFolder: string, routes: RouteInfo<string>[]) {
     const input = routes.reduce((entries, { page, file }) => {
@@ -413,19 +454,20 @@ export async function build(args: {
       appType: 'custom',
       configFile: false,
 
-      // plugins: [
-      //   nodeExternals({
-      //     exclude: optimizeDeps.include,
-      //   }) as any,
-      // ],
-
       define: vxrnOutput!.processEnvDefines,
 
-      ssr: {
-        noExternal: true,
-        external: ['react', 'react-dom'],
-        optimizeDeps: optimizeDepsNoRolldown,
-      },
+      ssr: isUnified
+        ? {
+            // in unified mode let the base (serverBuildConfig) set ssr.noExternal
+            // — default is now ['react', 'react-dom'] instead of `true`, so
+            // rolldown can externalize the rest.
+            optimizeDeps: optimizeDepsNoRolldown,
+          }
+        : {
+            noExternal: true,
+            external: ['react', 'react-dom'],
+            optimizeDeps: optimizeDepsNoRolldown,
+          },
 
       environments: {
         ssr: {
@@ -456,7 +498,10 @@ export async function build(args: {
           // prevents it from shaking out the exports
           preserveEntrySignatures: 'strict',
           input: input,
-          external: [],
+          // in unified mode, inherit externals from serverBuildConfig (user
+          // ssr.external / rolldownOptions.external). the legacy path resets
+          // them to [] so per-route files bundle everything.
+          ...(isUnified ? {} : { external: [] }),
           output: {
             entryFileNames: '[name]',
             exports: 'auto',
@@ -528,7 +573,7 @@ export async function build(args: {
   if (middlewareBuildInfo) {
     for (const middleware of manifest.middlewareRoutes) {
       const absoluteRoot = resolve(process.cwd(), options.root)
-      const fullPath = join(absoluteRoot, routerRoot, middleware.file)
+      const fullPath = normalizePath(join(absoluteRoot, routerRoot, middleware.file))
       const outChunks = middlewareBuildInfo.output.filter((x) => x.type === 'chunk')
       const chunk = outChunks.find((x) => x.facadeModuleId === fullPath)
       if (!chunk) throw new Error(`internal err finding middleware`)
@@ -537,7 +582,7 @@ export async function build(args: {
   }
 
   // for the require Sitemap in getRoutes
-  globalThis['require'] = createRequire(join(import.meta.url, '..'))
+  globalThis['require'] = createRequire(import.meta.dirname + '/')
 
   const assets: OutputAsset[] = []
 
@@ -607,7 +652,10 @@ export async function build(args: {
     // layout files start with _layout
     if (file.startsWith('_layout') && id.includes(`/${routerRoot}/`)) {
       // contextKey format is "./_layout.tsx" or "./subdir/_layout.tsx"
-      const relativePath = relative(process.cwd(), id).replace(`${routerRoot}/`, '')
+      const relativePath = normalizePath(relative(process.cwd(), id)).replace(
+        `${routerRoot}/`,
+        ''
+      )
       const contextKey = `./${relativePath}`
       layoutServerPaths.set(contextKey, output.fileName)
     }
@@ -650,10 +698,8 @@ export async function build(args: {
     }
 
     // resolve the full module path for this route
-    const routeModulePath = join(
-      resolve(process.cwd(), options.root),
-      routerRoot,
-      foundRoute.file.slice(2)
+    const routeModulePath = normalizePath(
+      join(resolve(process.cwd(), options.root), routerRoot, foundRoute.file.slice(2))
     )
 
     // find the server chunk containing this route
@@ -942,7 +988,7 @@ export async function build(args: {
 
     let exported
     try {
-      exported = await import(toAbsolute(serverJsPath))
+      exported = await import(toAbsoluteUrl(serverJsPath))
     } catch (err) {
       console.error(`Error importing page (original error)`, err)
       // err cause not showing in vite or something
@@ -1152,11 +1198,22 @@ export async function build(args: {
       }))
     }
 
-    // swap out for the built middleware path
+    // swap out for the built middleware path.
+    // page routes have compiled middleware paths attached via buildPage
+    // (buildInfo.middlewares). api routes don't go through buildPage, so fall
+    // back to the builtMiddlewares map keyed by the middleware source file.
     const buildInfo = builtRoutes.find((x) => x.routeFile === route.file)
-    if (built.middlewares && buildInfo?.middlewares) {
+    if (built.middlewares) {
       for (const [index, mw] of built.middlewares.entries()) {
-        mw.contextKey = buildInfo.middlewares[index]
+        const viaBuildInfo = buildInfo?.middlewares?.[index]
+        if (viaBuildInfo) {
+          mw.contextKey = viaBuildInfo
+          continue
+        }
+        const viaMiddlewareMap = builtMiddlewares[mw.contextKey]
+        if (viaMiddlewareMap) {
+          mw.contextKey = viaMiddlewareMap
+        }
       }
     }
 
@@ -1244,7 +1301,14 @@ export async function build(args: {
 
     case 'cloudflare': {
       // Generate lazy import functions - modules load on-demand, not all upfront
-      // Uses find_additional_modules in wrangler config to keep modules separate
+      // The worker config keeps route modules separate so they can stay lazy.
+      const workerSrcDir = join(options.root, outDir)
+      const getWorkerSourceImportPath = (routeFile: string) => {
+        const importPath = normalizePath(
+          relative(workerSrcDir, join(options.root, routerRoot, routeFile))
+        )
+        return importPath.startsWith('.') ? importPath : `./${importPath}`
+      }
       const pageRouteMap: string[] = []
       const apiRouteMap: string[] = []
       const middlewareRouteMap: string[] = []
@@ -1263,19 +1327,18 @@ export async function build(args: {
       // Generate lazy imports for API routes
       for (const route of buildInfoForWriting.manifest.apiRoutes) {
         if (route.file) {
-          // API files are built to dist/api/
-          // route.page is like "/api/hello", files are at "dist/api/api/hello.js"
-          // both vite and rolldown-vite replace brackets with underscores in output filenames
-          const apiFileName = route.page.slice(1).replace(/\[/g, '_').replace(/\]/g, '_')
-          const importPath = `./api/${apiFileName}.js`
+          // Import API routes from source so the Cloudflare plugin can apply its
+          // own unenv/CJS transforms instead of re-bundling pre-built chunks.
+          const importPath = getWorkerSourceImportPath(route.file)
           apiRouteMap.push(`  '${route.page}': () => import('${importPath}')`)
         }
       }
 
       // Generate lazy imports for middlewares
-      // The key must match the contextKey used to look up the middleware (e.g., "dist/middlewares/_middleware.js")
-      for (const [, builtPath] of Object.entries(builtMiddlewares)) {
-        const importPath = './' + builtPath.replace(new RegExp(`^${outDir}/`), '')
+      // Keep the built output path as the lookup key, but import the source
+      // file so the plugin owns the middleware dependency graph too.
+      for (const [sourceFile, builtPath] of Object.entries(builtMiddlewares)) {
+        const importPath = getWorkerSourceImportPath(sourceFile)
         middlewareRouteMap.push(`  '${builtPath}': () => import('${importPath}')`)
       }
 
@@ -1334,7 +1397,7 @@ export default {
     }
 
     try {
-      const response = await server.fetch(request)
+      const response = await server.fetch(request, env, ctx)
 
       // no route matched or 404 → try static assets
       if (!response || response.status === 404) {
@@ -1359,45 +1422,41 @@ export default {
 `
       await FSExtra.writeFile(workerSrcPath, workerCode)
 
-      // Bundle the worker using Vite/esbuild
-      // Cloudflare Workers with nodejs_compat supports Node.js built-ins
+      const projectName = await getCloudflareProjectName(options.root)
+      const userWranglerConfig = await loadUserWranglerConfig(options.root)
+      const wranglerInputConfig = createCloudflareWranglerConfig(
+        projectName,
+        userWranglerConfig?.config
+      )
+      wranglerInputConfig.main = relative(join(options.root, outDir), workerSrcPath)
+
+      const wranglerInputPath = join(options.root, outDir, '_wrangler.input.jsonc')
+      await FSExtra.writeFile(
+        wranglerInputPath,
+        `${JSON.stringify(wranglerInputConfig, null, 2)}\n`
+      )
+
+      // Bundle the worker using Cloudflare's Vite plugin so we pick up unenv
+      // polyfills and esmExternalRequirePlugin for Node-first CJS deps.
       console.info('\n [cloudflare] Bundling worker...')
-      await viteBuild({
+      const { cloudflare } = await import('@cloudflare/vite-plugin')
+      const builder = await createBuilder({
         root: options.root,
         mode: 'production',
         logLevel: 'warn',
-        build: {
-          outDir,
-          emptyOutDir: false,
-          // Use SSR mode with node target for proper Node.js module resolution
-          ssr: workerSrcPath,
-          rolldownOptions: {
-            external: [
-              // React Native dev tools - not needed in production
-              '@react-native/dev-middleware',
-              '@react-native/debugger-shell',
-              'metro',
-              'metro-core',
-              'metro-runtime',
-              // Native modules that can't run in workers
-              /\.node$/,
-            ],
-            output: {
-              entryFileNames: 'worker.js',
-              format: 'es',
-              // Keep dynamic imports separate for lazy loading
-              inlineDynamicImports: false,
-            },
-          },
-          minify: true,
-          target: 'esnext',
-        },
+        configFile: false,
         define: {
           'process.env.NODE_ENV': JSON.stringify('production'),
           'process.env.VITE_ENVIRONMENT': JSON.stringify('ssr'),
+          'process.env.ONE_CACHE_KEY': JSON.stringify(constants.CACHE_KEY),
         },
+        plugins: [
+          cloudflare({
+            configPath: wranglerInputPath,
+            viteEnvironment: { name: 'worker' },
+          }),
+        ],
         resolve: {
-          conditions: ['workerd', 'worker', 'node', 'module', 'default'],
           alias: [
             // rolldown can't parse react-native's Flow syntax; alias to react-native-web for ssr
             {
@@ -1418,37 +1477,35 @@ export default {
             },
           ],
         },
-        ssr: {
-          target: 'node',
-          noExternal: true,
+        build: {
+          outDir,
+          emptyOutDir: false,
+          rolldownOptions: {
+            // Match the main web build behavior so RN packages that import
+            // native-only symbols from react-native can still bundle against
+            // the react-native-web alias in the worker graph.
+            shimMissingExports: true,
+          },
         },
       })
+      const workerEnv = builder.environments.worker
+      if (!workerEnv) {
+        throw new Error('[one] plugin did not register "worker" environment')
+      }
+      await builder.build(workerEnv)
 
       // Clean up temp file
       await FSExtra.remove(workerSrcPath)
-
-      // Use jsonc for wrangler config (recommended for new projects)
-      // Use assets with run_worker_first so all requests go through worker (enables middleware on SSG pages)
-      const projectName = await getCloudflareProjectName(options.root)
-      const userWranglerConfig = await loadUserWranglerConfig(options.root)
-      const wranglerConfig = createCloudflareWranglerConfig(
-        projectName,
-        userWranglerConfig?.config
-      )
+      await FSExtra.remove(wranglerInputPath)
 
       if (userWranglerConfig) {
         console.info(
-          ` [cloudflare] Merging ${relative(options.root, userWranglerConfig.path)} into ${outDir}/wrangler.jsonc`
+          ` [cloudflare] Merging ${relative(options.root, userWranglerConfig.path)} into ${outDir}/worker/wrangler.json`
         )
       }
 
-      await FSExtra.writeFile(
-        join(options.root, outDir, 'wrangler.jsonc'),
-        `${JSON.stringify(wranglerConfig, null, 2)}\n`
-      )
-
-      postBuildLogs.push(`Cloudflare worker bundled at ${outDir}/worker.js`)
-      postBuildLogs.push(`To deploy: cd ${outDir} && wrangler deploy`)
+      postBuildLogs.push(`Cloudflare worker bundled at ${outDir}/worker/index.js`)
+      postBuildLogs.push(`To deploy: cd ${outDir}/worker && wrangler deploy`)
 
       break
     }

package/src/cli/buildPage.ts

@@ -5,7 +5,7 @@ import { LOADER_JS_POSTFIX_UNCACHED } from '../constants'
 import type { LoaderProps } from '../types'
 import { getLoaderPath, getPreloadCSSPath, getPreloadPath } from '../utils/cleanUrl'
 import { isResponse } from '../utils/isResponse'
-import { toAbsolute } from '../utils/toAbsolute'
+import { toAbsolute, toAbsoluteUrl } from '../utils/toAbsolute'
 import { replaceLoader } from '../vite/replaceLoader'
 import type { One, RouteInfo } from '../vite/types'
 
@@ -174,7 +174,7 @@ prefetchCSS()
     recordTiming('writeCSSPreload', performance.now() - t0)
 
     t0 = performance.now()
-    const exported = await import(toAbsolute(serverJsPath))
+    const exported = await import(toAbsoluteUrl(serverJsPath))
     recordTiming('importServerModule', performance.now() - t0)
 
     const loaderProps: LoaderProps = { path, params }
@@ -195,7 +195,7 @@ prefetchCSS()
             // derive server dir from clientDir (e.g. dist/client -> dist/server)
             const serverDir = join(clientDir, '..', 'server')
             const layoutExported = await import(
-              toAbsolute(join(serverDir, layoutServerPath))
+              toAbsoluteUrl(join(serverDir, layoutServerPath))
             )
             const layoutLoaderData = await layoutExported?.loader?.(loaderProps)
             return { contextKey: layout.contextKey, loaderData: layoutLoaderData }
@@ -478,7 +478,7 @@ params:\n\n${JSON.stringify(params || null, null, 2)}`
 
 async function getRender(serverEntry: string) {
   try {
-    const serverImport = await import(serverEntry)
+    const serverImport = await import(toAbsoluteUrl(serverEntry))
 
     const render =
       serverImport.default.render ||

package/src/constants.ts

@@ -3,10 +3,25 @@ import type { One } from './vite/types'
 
 export const isWebClient =
   process.env.TAMAGUI_TARGET !== 'native' && typeof window !== 'undefined'
+
 export const isWebServer =
   process.env.TAMAGUI_TARGET !== 'native' && typeof window === 'undefined'
+
 export const isNative = process.env.TAMAGUI_TARGET === 'native'
 
+/**
+ * True only in a browser main-thread context with a navigable history —
+ * i.e. `window` AND `window.history` are available. Excludes native,
+ * SSR, web workers / service workers (no `window`), and exotic sandboxed
+ * environments where `window` exists but history is stripped. Use this
+ * for guarding any `window.history` / `window.location` access so
+ * intercept routes, URL masking, etc. don't assume a full browser.
+ */
+export const hasWebHistory =
+  isWebClient &&
+  typeof window.history !== 'undefined' &&
+  typeof window.location !== 'undefined'
+
 export const CACHE_KEY = `${process.env.ONE_CACHE_KEY ?? Math.round(Math.random() * 100_000_000)}`
 
 export const LOADER_JS_POSTFIX_UNCACHED = `_vxrn_loader.js`

package/src/createAPIRoute.ts

@@ -2,9 +2,40 @@ import type { OneRouter } from './interfaces/router'
 
 type MaybePromise<T> = T | Promise<T>
 
+/**
+ * Minimal shape of the Cloudflare Workers `ExecutionContext`.
+ * Use `context.worker?.executionCtx?.waitUntil(promise)` from an API handler
+ * to keep the worker alive for fire-and-forget background work after the
+ * response has been sent.
+ */
+export type WorkerExecutionContext = {
+  waitUntil: (promise: Promise<unknown>) => void
+  passThroughOnException: () => void
+}
+
+/** Cloudflare Workers `env` bindings. Shape is app-specific; `unknown` by default. */
+export type WorkerEnv = Record<string, unknown>
+
+/**
+ * Worker-runtime context surfaced on API handlers when running under an edge
+ * runtime (Cloudflare Workers). Undefined in dev/Node.
+ */
+export type WorkerContext = {
+  env?: WorkerEnv
+  executionCtx?: WorkerExecutionContext
+}
+
+export type APIRouteContext<
+  Params extends Record<string, string> = Record<string, string>,
+> = {
+  params: Params
+  /** Present on worker runtimes (Cloudflare Workers). Undefined in dev/Node. */
+  worker?: WorkerContext
+}
+
 type APIRouteHandler<Params extends Record<string, string> = Record<string, string>> = (
   request: Request,
-  context: { params: Params }
+  context: APIRouteContext<Params>
 ) => MaybePromise<Response>
 
 /**
@@ -15,8 +46,10 @@ type APIRouteHandler<Params extends Record<string, string> = Record<string, stri
  * // app/api/users/[id]+api.ts
  * import { createAPIRoute } from 'one'
  *
- * export const GET = createAPIRoute<'/api/users/[id]'>((request, { params }) => {
+ * export const GET = createAPIRoute<'/api/users/[id]'>((request, { params, worker }) => {
  *   // params.id is typed as string
+ *   // on cloudflare workers, worker.executionCtx.waitUntil() keeps background work alive
+ *   worker?.executionCtx?.waitUntil(trackEvent(params.id))
  *   return Response.json({ id: params.id })
  * })
  * ```

package/src/createApp.tsx

@@ -8,6 +8,7 @@ import { render } from './render'
 import { initClientMatches } from './router/router'
 import { registerPreloadedRoute } from './router/useViteRoutes'
 import { setupSkewProtection } from './skewProtection'
+import { handleSkewError } from './utils/dynamicImport'
 import { findRootLayout } from './utils/findRootLayout'
 import type { RenderAppProps } from './types'
 import { getServerHeadInsertions } from './useServerHeadInsertion'
@@ -241,12 +242,7 @@ export function createApp(options: CreateAppProps) {
   if (typeof window !== 'undefined' && process.env.ONE_SKEW_PROTECTION !== 'false') {
     window.addEventListener('vite:preloadError', (e) => {
       e.preventDefault()
-      const key = '__one_skew_reload'
-      const last = sessionStorage.getItem(key)
-      if (!last || Date.now() - Number(last) > 10_000) {
-        sessionStorage.setItem(key, String(Date.now()))
-        window.location.reload()
-      }
+      handleSkewError()
     })
   }
 

package/src/createHandleRequest.ts

@@ -120,7 +120,9 @@ export async function resolveAPIRoute(
   handlers: RequestHandlers,
   request: Request,
   url: URL,
-  route: RouteInfoCompiled
+  route: RouteInfoCompiled,
+  env?: unknown,
+  executionCtx?: unknown
 ) {
   const { pathname } = url
   const params = getRouteParams(pathname, route)
@@ -145,7 +147,9 @@ export async function resolveAPIRoute(
             },
           }),
         request,
-        params || {}
+        params || {},
+        env,
+        executionCtx
       )
     } catch (err) {
       if (isResponse(err)) {

package/src/hooks.tsx

@@ -2,6 +2,7 @@ import React, { createContext, useContext } from 'react'
 import type { OneRouter } from './interfaces/router'
 import { router } from './router/imperative-api'
 import { RouteParamsContext, useRouteNode } from './router/Route'
+import { mergeDynamicParams } from './router/params'
 import { RouteInfoContext } from './router/RouteInfoContext'
 import { navigationRef, useStoreRootState, useStoreRouteInfo } from './router/router'
 import { getServerContext } from './vite/one-server-only'
@@ -177,7 +178,14 @@ export const useGlobalSearchParams = useActiveParams
  * ```
  */
 export function useParams<TParams extends object = SearchParams>(): Partial<TParams> {
-  const params = React.useContext(RouteParamsContext) ?? {}
+  const contextParams = React.useContext(RouteParamsContext) ?? {}
+  const routeNode = useRouteNode()
+  const routeInfoParams = useRouteInfo().params
+
+  const params = React.useMemo(
+    () => mergeDynamicParams(contextParams, routeNode?.dynamic, routeInfoParams),
+    [contextParams, routeInfoParams, routeNode]
+  )
 
   return React.useMemo(() => {
     return Object.fromEntries(

package/src/index.ts

@@ -53,7 +53,14 @@ export { onClientLoaderResolve } from './clientLoaderResolver'
 // middleware
 export { createMiddleware, type Middleware } from './createMiddleware'
 // api routes
-export { createAPIRoute, type APIRouteHandler } from './createAPIRoute'
+export {
+  createAPIRoute,
+  type APIRouteContext,
+  type APIRouteHandler,
+  type WorkerContext,
+  type WorkerEnv,
+  type WorkerExecutionContext,
+} from './createAPIRoute'
 export { getURL } from './getURL'
 export { Head } from './head'
 // for easier expo-router migration

package/src/metro-config/getViteMetroPluginOptions.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest'
+import { normalizeReSource } from './getViteMetroPluginOptions'
+
+// String.raw avoids double-escaping: String.raw`[\\/]` is the 5-char string [ \ \ / ]
+// which is exactly what regex.source produces for /[\\/]/
+
+describe('normalizeReSource', () => {
+  it(String.raw`[\\/] to \/`, () => {
+    expect(normalizeReSource(String.raw`[\\/]`)).toBe(String.raw`\/`)
+  })
+
+  it(String.raw`[^\\/] to [^/]`, () => {
+    expect(normalizeReSource(String.raw`[^\\/]`)).toBe('[^/]')
+  })
+
+  it('full Windows micromatch regex', () => {
+    // micromatch.makeRe('**/*.web.(ts|tsx)').source on Windows (picomatch 2.x)
+    const windowsSource = String.raw`^(?:(?:^|[\\/]|(?:(?:(?!(?:^|[\\/])\.).)*?)[\\/])(?!\.)(?=.)[^\\/]*?\.web\.(ts|tsx))$`
+    const posixSource = String.raw`^(?:(?:^|\/|(?:(?:(?!(?:^|\/)\.).)*?)\/)(?!\.)(?=.)[^/]*?\.web\.(ts|tsx))$`
+
+    expect(normalizeReSource(windowsSource)).toBe(posixSource)
+  })
+
+  it('no-op for POSIX regex', () => {
+    const posixSource = String.raw`^(?:(?:^|\/|(?:(?:(?!(?:^|\/)\.).)*?)\/)(?!\.)(?=.)[^/]*?\.web\.(ts|tsx))$`
+
+    expect(normalizeReSource(posixSource)).toBe(posixSource)
+  })
+
+  it('multiple groups in one source', () => {
+    const source = String.raw`a[\\/]b[\\/]c[^\\/]d`
+    expect(normalizeReSource(source)).toBe(String.raw`a\/b\/c[^/]d`)
+  })
+})