@vxrn/vite-plugin-metro 2.0.0-beta.33.1 → 2.0.0-beta.362.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vxrn/vite-plugin-metro",
-  "version": "2.0.0-beta.33.1",
+  "version": "2.0.0-beta.362.1",
   "sideEffects": false,
   "type": "module",
   "main": "dist/cjs",
@@ -61,11 +61,9 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@expo/metro-config": "~57.0.7",
-    "expo": "~57.0.11",
-    "metro": "^0.84.3",
-    "metro-config": "^0.84.3",
-    "react-native": "0.86.2",
+    "metro": "^0.87.0",
+    "metro-config": "^0.87.0",
+    "react-native": "0.87.1",
     "vite": "^8.2.2"
   },
   "dependencies": {
@@ -74,12 +72,13 @@
     "@jridgewell/remapping": "^2.3.0",
     "@jridgewell/trace-mapping": "^0.3.25",
     "@oxc-project/runtime": "^0.112.0",
-    "@vxrn/compiler": "2.0.0-beta.33.1",
-    "@vxrn/debug": "2.0.0-beta.33.1",
-    "@vxrn/utils": "2.0.0-beta.33.1",
-    "babel-preset-expo": "~57.0.5",
+    "@react-native/babel-preset": "^0.87.1",
+    "@react-native/metro-config": "^0.87.1",
+    "@vxrn/compiler": "2.0.0-beta.362.1",
+    "@vxrn/debug": "2.0.0-beta.362.1",
+    "@vxrn/utils": "2.0.0-beta.362.1",
     "esbuild": "^0.25.12",
-    "fast-flow-transform": "^0.0.3",
+    "flow-parser": "^0.331.0",
     "launch-editor": "^2.10.0",
     "magic-string": "^0.30.21",
     "micromatch": "^4.0.8",
@@ -89,22 +88,21 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.3",
-    "@expo/metro-config": "~57.0.7",
-    "@react-native/dev-middleware": "^0.86.2",
-    "@tamagui/build": "2.6.2",
+    "@react-native/dev-middleware": "^0.87.1",
+    "@tamagui/build": "3.0.0-beta.1432.1",
     "@types/babel__helper-plugin-utils": "^7",
     "@types/node": "^24.10.0",
     "depcheck": "^1.4.7",
-    "expo": "~57.0.11",
-    "metro": "^0.84.3",
-    "metro-config": "^0.84.3",
-    "react-native": "0.86.2",
+    "metro": "^0.87.0",
+    "metro-config": "^0.87.0",
+    "react-native": "0.87.1",
     "vite": "^8.2.2",
     "vitest": "^4.1.0"
   },
   "publishConfig": {
     "access": "public"
   },
+  "releaseSourceCommit": "6b489d521782af129132654d2baeb318f4bc2fdc",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/onejs/one.git",

package/src/babel-plugins/import-meta-env-plugin.ts

@@ -9,7 +9,7 @@ type PluginOptions = {
 /**
  * Babel plugin to replace `import.meta.env.*` and `process.env.*` with env values.
  *
- * Platform-specific env vars (VITE_ENVIRONMENT, VITE_NATIVE, EXPO_OS, TAMAGUI_ENVIRONMENT)
+ * Platform-specific env vars (VITE_ENVIRONMENT, VITE_NATIVE, ONE_PLATFORM, EXPO_OS, TAMAGUI_ENVIRONMENT)
  * are automatically injected based on the babel caller's platform.
  *
  * This plugin is referenced by name since Metro runs transformers in separate workers:

package/src/env/platformEnv.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getPlatformEnv,
+  getPlatformEnvDefine,
+  metroPlatformToViteEnvironment,
+} from './platformEnv'
+
+describe('one platform env contract', () => {
+  it('exposes ONE_PLATFORM for every vite environment', () => {
+    expect(getPlatformEnv('ios').ONE_PLATFORM).toBe('ios')
+    expect(getPlatformEnv('android').ONE_PLATFORM).toBe('android')
+    expect(getPlatformEnv('client').ONE_PLATFORM).toBe('web')
+    expect(getPlatformEnv('ssr').ONE_PLATFORM).toBe('web')
+  })
+
+  it('defines the Expo platform alias only on native', () => {
+    for (const environment of ['ios', 'android'] as const) {
+      expect(getPlatformEnv(environment).EXPO_OS).toBe(
+        getPlatformEnv(environment).ONE_PLATFORM
+      )
+      const define = getPlatformEnvDefine(environment)
+      expect(define['process.env.EXPO_OS']).toBe(define['process.env.ONE_PLATFORM'])
+      expect(define['import.meta.env.EXPO_OS']).toBe(
+        define['import.meta.env.ONE_PLATFORM']
+      )
+    }
+    for (const environment of ['client', 'ssr'] as const) {
+      expect(getPlatformEnv(environment)).not.toHaveProperty('EXPO_OS')
+      const define = getPlatformEnvDefine(environment)
+      expect(define).not.toHaveProperty('process.env.EXPO_OS')
+      expect(define).not.toHaveProperty('import.meta.env.EXPO_OS')
+    }
+    const define = getPlatformEnvDefine('ios')
+    expect(define['process.env.ONE_PLATFORM']).toBe('"ios"')
+    expect(define['import.meta.env.ONE_PLATFORM']).toBe('"ios"')
+  })
+
+  it('maps metro platforms to vite environments without probing', () => {
+    expect(metroPlatformToViteEnvironment('ios')).toBe('ios')
+    expect(metroPlatformToViteEnvironment('android')).toBe('android')
+    expect(metroPlatformToViteEnvironment(null)).toBe('client')
+    expect(metroPlatformToViteEnvironment(undefined)).toBe('client')
+  })
+})

package/src/env/platformEnv.ts

@@ -4,7 +4,8 @@ export type ViteEnvironment = 'client' | 'ssr' | 'ios' | 'android'
 export type PlatformEnv = {
   VITE_ENVIRONMENT: ViteEnvironment
   VITE_NATIVE: '' | '1'
-  EXPO_OS: 'web' | 'ios' | 'android'
+  ONE_PLATFORM: 'web' | 'ios' | 'android'
+  EXPO_OS?: 'ios' | 'android'
   TAMAGUI_TARGET: 'web' | 'native'
   TAMAGUI_ENVIRONMENT: ViteEnvironment
 }
@@ -13,20 +14,21 @@ const platformEnvMap: Record<ViteEnvironment, PlatformEnv> = {
   client: {
     VITE_ENVIRONMENT: 'client',
     VITE_NATIVE: '',
-    EXPO_OS: 'web',
+    ONE_PLATFORM: 'web',
     TAMAGUI_TARGET: 'web',
     TAMAGUI_ENVIRONMENT: 'client',
   },
   ssr: {
     VITE_ENVIRONMENT: 'ssr',
     VITE_NATIVE: '',
-    EXPO_OS: 'web',
+    ONE_PLATFORM: 'web',
     TAMAGUI_TARGET: 'web',
     TAMAGUI_ENVIRONMENT: 'ssr',
   },
   ios: {
     VITE_ENVIRONMENT: 'ios',
     VITE_NATIVE: '1',
+    ONE_PLATFORM: 'ios',
     EXPO_OS: 'ios',
     TAMAGUI_TARGET: 'native',
     TAMAGUI_ENVIRONMENT: 'ios',
@@ -34,6 +36,7 @@ const platformEnvMap: Record<ViteEnvironment, PlatformEnv> = {
   android: {
     VITE_ENVIRONMENT: 'android',
     VITE_NATIVE: '1',
+    ONE_PLATFORM: 'android',
     EXPO_OS: 'android',
     TAMAGUI_TARGET: 'native',
     TAMAGUI_ENVIRONMENT: 'android',

package/src/index.ts

@@ -1,7 +1,5 @@
 export { metroPlugin } from './plugins/metroPlugin'
 export type { MetroPluginOptions } from './plugins/metroPlugin'
-export { expoManifestRequestHandlerPlugin } from './plugins/expoManifestRequestHandlerPlugin'
-export type { ExpoManifestRequestHandlerPluginPluginOptions } from './plugins/expoManifestRequestHandlerPlugin'
 export {
   getPlatformEnv,
   getPlatformEnvDefine,

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

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import { getMetroBabelConfigFromViteConfig } from './getMetroBabelConfigFromViteConfig'
+
+function viteConfig(overrides: Record<string, any> = {}) {
+  return {
+    mode: 'development',
+    base: '/',
+    env: {},
+    define: {},
+    ...overrides,
+  } as any
+}
+
+function pluginEnv(config: any): Record<string, any> {
+  const babelConfig = getMetroBabelConfigFromViteConfig(config)
+  const plugin = (babelConfig.plugins as any[])[0]
+  return plugin[1].env
+}
+
+describe('metro babel env contract', () => {
+  it('picks up ONE_PUBLIC_ keys by default with Expo aliases', () => {
+    const env = pluginEnv(viteConfig({ env: { ONE_PUBLIC_API: 'https://api.test' } }))
+    expect(env.ONE_PUBLIC_API).toBe('https://api.test')
+    expect(env.EXPO_PUBLIC_API).toBe('https://api.test')
+  })
+
+  it('harvests ONE_PLATFORM from defines for parity with rolldown', () => {
+    const env = pluginEnv(viteConfig({ define: { 'process.env.ONE_PLATFORM': '"ios"' } }))
+    expect(env.ONE_PLATFORM).toBe('ios')
+  })
+
+  it('accepts an Expo env prefix', () => {
+    expect(pluginEnv(viteConfig({ envPrefix: ['VITE_', 'EXPO_PUBLIC_'] }))).toMatchObject(
+      { MODE: 'development' }
+    )
+  })
+
+  it('accepts Expo keys without creating One names', () => {
+    expect(pluginEnv(viteConfig({ env: { EXPO_PUBLIC_API: 'x' } }))).toMatchObject({
+      EXPO_PUBLIC_API: 'x',
+    })
+    expect(
+      pluginEnv(viteConfig({ env: { EXPO_PUBLIC_API: 'x' } }))
+    ).not.toHaveProperty('ONE_PUBLIC_API')
+  })
+
+  it('accepts Expo platform defines for the platform plugin to override', () => {
+    expect(
+      pluginEnv(viteConfig({ define: { 'process.env.EXPO_OS': '"ios"' } })).EXPO_OS
+    ).toBe('ios')
+  })
+})

package/src/metro-config/getMetroBabelConfigFromViteConfig.ts

@@ -1,10 +1,11 @@
 import type { ResolvedConfig } from 'vite'
 import type { TransformOptions } from '@babel/core'
+import { withExpoPublicEnvAliases } from '@vxrn/utils/publicEnv'
 
 /**
  * Creates babel config for Metro transforms from Vite config.
  *
- * Platform-specific env vars (VITE_ENVIRONMENT, VITE_NATIVE, EXPO_OS, TAMAGUI_ENVIRONMENT)
+ * Platform-specific env vars (VITE_ENVIRONMENT, VITE_NATIVE, ONE_PLATFORM, EXPO_OS, TAMAGUI_ENVIRONMENT)
  * are handled by the import-meta-env-plugin based on caller.platform and always take precedence.
  */
 export function getMetroBabelConfigFromViteConfig(
@@ -18,28 +19,28 @@ export function getMetroBabelConfigFromViteConfig(
     SSR: false,
   }
 
-  const envPrefix = config.envPrefix || ['VITE_', 'EXPO_PUBLIC_']
+  const envPrefix = config.envPrefix || ['VITE_', 'ONE_PUBLIC_', 'EXPO_PUBLIC_']
   const prefixes = Array.isArray(envPrefix) ? envPrefix : [envPrefix]
 
   for (const key of Object.keys(config.env)) {
     if (prefixes.some((p) => key.startsWith(p))) {
-      importMetaEnv[key] = process.env[key]
+      importMetaEnv[key] = process.env[key] ?? config.env[key]
     }
   }
 
   // also harvest keys from config.define (populated by env-defining plugins like one's).
   // we union the user's envPrefix with framework-level defaults so we still pick up
-  // VITE_/ONE_/EXPO_PUBLIC_ even when another plugin replaces envPrefix wholesale
+  // VITE_/ONE_PUBLIC_/EXPO_PUBLIC_/ONE_ even when another plugin replaces envPrefix wholesale
   // (e.g. some plugins set it to a single project-specific prefix).
   const definePrefixes = Array.from(
-    new Set([...prefixes, 'VITE_', 'ONE_', 'EXPO_PUBLIC_'])
+    new Set([...prefixes, 'VITE_', 'ONE_PUBLIC_', 'EXPO_PUBLIC_', 'ONE_'])
   )
   for (const defineKey of Object.keys(config.define || {})) {
     const m = defineKey.match(/^process\.env\.([A-Z][A-Z0-9_]*)$/)
     if (!m) continue
     const key = m[1]
     if (key in importMetaEnv) continue
-    if (!definePrefixes.some((p) => key.startsWith(p))) continue
+    if (key !== 'EXPO_OS' && !definePrefixes.some((p) => key.startsWith(p))) continue
     const raw = config.define![defineKey]
     try {
       importMetaEnv[key] = typeof raw === 'string' ? JSON.parse(raw) : raw
@@ -52,7 +53,7 @@ export function getMetroBabelConfigFromViteConfig(
     plugins: [
       [
         '@vxrn/vite-plugin-metro/babel-plugins/import-meta-env-plugin',
-        { env: importMetaEnv },
+        { env: withExpoPublicEnvAliases(importMetaEnv) },
       ],
     ],
   }

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

@@ -0,0 +1,263 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import { runInNewContext } from 'node:vm'
+import { resolveConfig } from 'vite'
+import type { ResolverConfigT } from 'metro-config'
+import type { MetroPluginOptions } from '../plugins/metroPlugin'
+import { afterAll, describe, expect, it } from 'vitest'
+import {
+  buildMetroConfigInputFromViteConfig,
+  getMetroConfigFromViteConfig,
+} from './getMetroConfigFromViteConfig'
+
+const tmpDirs: string[] = []
+
+describe('vite package dedupe through real metro bundles', () => {
+  it.each([
+    ['input', 'android'],
+    ['input', 'ios'],
+    ['full', 'android'],
+    ['full', 'ios'],
+  ])(
+    'keeps one registration and native resolution for %s/%s',
+    async (mode, platform) => {
+      const workspaceRoot = path.resolve(__dirname, '../../../../')
+      const scratch = path.join(workspaceRoot, 'scripts/tmp')
+      fs.mkdirSync(scratch, { recursive: true })
+      const fixtureRoot = fs.mkdtempSync(path.join(scratch, 'metro-dedupe-'))
+      tmpDirs.push(fixtureRoot)
+      fs.writeFileSync(path.join(fixtureRoot, 'package.json'), '{"private":true}')
+      const writePackage = (directory: string, name: string, source: string) => {
+        fs.mkdirSync(directory, { recursive: true })
+        fs.writeFileSync(
+          path.join(directory, 'package.json'),
+          JSON.stringify({ name, version: '1.0.0', main: 'index.js' })
+        )
+        fs.writeFileSync(path.join(directory, 'index.js'), source)
+      }
+      const registry = (name: string) => `
+globalThis.registrations = (globalThis.registrations || 0) + 1;
+if (globalThis.registrations > 1) throw new Error('duplicate native view');
+module.exports = ${JSON.stringify(name)};
+`
+      const rootRegistry = path.join(fixtureRoot, 'node_modules/@fixture/registry')
+      writePackage(rootRegistry, '@fixture/registry', registry('root'))
+      fs.writeFileSync(
+        path.join(rootRegistry, 'package.json'),
+        JSON.stringify({
+          name: '@fixture/registry',
+          version: '1.0.0',
+          exports: {
+            '.': { 'react-native': './index.js', default: './wrong.js' },
+            './platform': './platform.js',
+          },
+        })
+      )
+      fs.writeFileSync(
+        path.join(rootRegistry, 'wrong.js'),
+        "throw new Error('native export condition lost');"
+      )
+      fs.writeFileSync(
+        path.join(rootRegistry, 'platform.js'),
+        "module.exports='export-subpath';"
+      )
+      const nativePackage = path.join(fixtureRoot, 'node_modules/@fixture/native')
+      writePackage(nativePackage, '@fixture/native', "module.exports='wrong';")
+      fs.writeFileSync(path.join(nativePackage, 'platform.js'), "module.exports='wrong';")
+      for (const target of ['ios', 'android']) {
+        fs.writeFileSync(
+          path.join(nativePackage, `platform.${target}.js`),
+          `module.exports=${JSON.stringify(target)};`
+        )
+      }
+      writePackage(
+        path.join(fixtureRoot, 'node_modules/@fixture/registry-extra'),
+        '@fixture/registry-extra',
+        "module.exports='wrong-root';"
+      )
+      writePackage(
+        path.join(fixtureRoot, 'node_modules/plain'),
+        'plain',
+        "module.exports='root';"
+      )
+      for (const name of ['first', 'second']) {
+        const directory = path.join(fixtureRoot, `node_modules/@fixture/${name}`)
+        writePackage(
+          directory,
+          `@fixture/${name}`,
+          `module.exports=[
+require('@fixture/registry'), require('@fixture/registry/platform'), require('@fixture/native/platform'),
+require('@fixture/registry-extra'), require('plain'), require('./local'), require('@fixture/alias')];`
+        )
+        fs.writeFileSync(
+          path.join(directory, 'local.js'),
+          `module.exports=${JSON.stringify(name)};`
+        )
+        writePackage(
+          path.join(directory, 'node_modules/@fixture/native'),
+          '@fixture/native',
+          `module.exports=${JSON.stringify(name)};`
+        )
+        writePackage(
+          path.join(directory, 'node_modules/@fixture/registry'),
+          '@fixture/registry',
+          registry(name)
+        )
+        writePackage(
+          path.join(directory, 'node_modules/@fixture/registry-extra'),
+          '@fixture/registry-extra',
+          `module.exports=${JSON.stringify(name)};`
+        )
+        writePackage(
+          path.join(directory, 'node_modules/plain'),
+          'plain',
+          `module.exports=${JSON.stringify(name)};`
+        )
+      }
+      const alias = path.join(fixtureRoot, 'alias.js')
+      fs.writeFileSync(alias, "module.exports='custom';")
+      const resolver: Partial<ResolverConfigT> = {
+        resolveRequest: (context, name, target) =>
+          name === '@fixture/alias'
+            ? { type: 'sourceFile', filePath: alias }
+            : context.resolveRequest(context, name, target),
+      }
+      const viteConfig = await resolveConfig(
+        {
+          root: workspaceRoot,
+          configFile: false,
+          resolve: { dedupe: ['@fixture/registry', '@fixture/native', 'plain'] },
+        },
+        'build'
+      )
+      const options = {
+        watchman: false,
+        argv: { projectRoot: fixtureRoot },
+        defaultConfigOverrides: (config) => ({
+          resolver: { ...config?.resolver, ...resolver },
+        }),
+      } satisfies MetroPluginOptions
+      const config =
+        mode === 'input'
+          ? (await buildMetroConfigInputFromViteConfig(viteConfig, options)).defaultConfig
+          : await getMetroConfigFromViteConfig(viteConfig, options)
+      const entry = path.join(fixtureRoot, 'entry.js')
+      fs.writeFileSync(
+        entry,
+        "globalThis.values=[require('@fixture/first'),require('@fixture/second')];"
+      )
+      const require = createRequire(path.join(workspaceRoot, 'package.json'))
+      const Server = require('metro/private/Server').default
+      const output = require('metro/private/shared/output/bundle')
+      const server = new Server({ ...config, maxWorkers: 1 })
+      try {
+        const bundle = await output.build(server, {
+          entryFile: entry,
+          platform,
+          dev: false,
+          minify: false,
+        })
+        const observed = { registrations: 0, values: [] }
+        runInNewContext(bundle.code, observed)
+        expect(observed.registrations).toBe(1)
+        expect(observed.values).toEqual([
+          ['root', 'export-subpath', platform, 'first', 'root', 'first', 'custom'],
+          ['root', 'export-subpath', platform, 'second', 'root', 'second', 'custom'],
+        ])
+      } finally {
+        await server.end()
+      }
+    },
+    180_000
+  )
+})
+
+afterAll(() => {
+  for (const tmpDir of tmpDirs) {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  }
+})
+
+describe('bare main module entry', () => {
+  it('survives a resolver-replacing defaultConfigOverrides', async () => {
+    const workspaceRoot = path.resolve(__dirname, '../../../../')
+    const fixtureRoot = fs.mkdtempSync(path.join(workspaceRoot, '.tmp-metro-entry-'))
+    tmpDirs.push(fixtureRoot)
+    fs.writeFileSync(
+      path.join(fixtureRoot, 'package.json'),
+      JSON.stringify({ name: 'tmp-metro-entry', private: true })
+    )
+
+    const seen: string[] = []
+    const { defaultConfig } = await buildMetroConfigInputFromViteConfig(
+      { root: fixtureRoot } as any,
+      {
+        mainModuleName: 'one/metro-entry',
+        watchman: false,
+        defaultConfigOverrides: {
+          resolver: {
+            sourceExts: ['js'],
+          },
+        },
+      } as any
+    )
+
+    expect((defaultConfig as any).watchFolders).toContain(workspaceRoot)
+    expect((defaultConfig as any).resolver.nodeModulesPaths).toContain(
+      path.join(workspaceRoot, 'node_modules')
+    )
+
+    const context = {
+      originModulePath: `${fixtureRoot}/.`,
+      resolveRequest: (_ctx: any, name: string) => {
+        seen.push(name)
+        return { type: 'sourceFile', filePath: name }
+      },
+    }
+    await (defaultConfig as any).resolver.resolveRequest(
+      context,
+      './one/metro-entry',
+      'ios'
+    )
+    expect(seen).toEqual(['one/metro-entry'])
+
+    await (defaultConfig as any).resolver.resolveRequest(context, 'react-native', 'ios')
+    expect(seen).toEqual(['one/metro-entry', 'react-native'])
+  })
+})
+
+describe('watch exclusions', () => {
+  it("block the app's build output but not a dependency's dist/server", async () => {
+    const workspaceRoot = path.resolve(__dirname, '../../../../')
+    const fixtureRoot = fs.mkdtempSync(path.join(workspaceRoot, '.tmp-metro-block-'))
+    tmpDirs.push(fixtureRoot)
+    fs.writeFileSync(
+      path.join(fixtureRoot, 'package.json'),
+      JSON.stringify({ name: 'tmp-metro-block', private: true })
+    )
+
+    const { defaultConfig } = await buildMetroConfigInputFromViteConfig(
+      { root: fixtureRoot } as any,
+      { watchman: false } as any
+    )
+    const blockList: RegExp[] = (defaultConfig as any).resolver.blockList
+    const blocked = (file: string) => blockList.some((pattern) => pattern.test(file))
+
+    expect(blocked(path.join(fixtureRoot, 'dist', 'server', 'entry.js'))).toBe(true)
+    expect(blocked(path.join(fixtureRoot, 'dist', 'static', 'index.html'))).toBe(true)
+    expect(
+      blocked(
+        path.join(
+          fixtureRoot,
+          'node_modules',
+          '@o',
+          'helpers',
+          'dist',
+          'server',
+          'ensureEnv.js'
+        )
+      )
+    ).toBe(false)
+  })
+})