vxrn 1.12.8 → 1.13.0

package/src/utils/getReactNativeBundle.ts

@@ -1,243 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { dirname, relative } from 'node:path'
-import { createBuilder } from 'vite'
-// import { buildEnvironment } from './fork/vite/build'
-import { resolvePath } from '@vxrn/resolve'
-import type { VXRNOptionsFilled } from '../config/getOptionsFilled'
-import { getReactNativeBuildConfig } from '../config/getReactNativeBuildConfig'
-import { filterPluginsForNative } from './filterPluginsForNative'
-import { getCacheDir } from './getCacheDir'
-import {
-  isBuildingNativeBundle,
-  setIsBuildingNativeBundle,
-} from './isBuildingNativeBundle'
-import { prebuildReactNativeModules } from './swapPrebuiltReactModules'
-
-// used for normalizing hot reloads
-export let entryRoot = ''
-
-let cachedReactNativeBundles: Record<string, string | undefined> = {}
-
-export function clearCachedBundle() {
-  cachedReactNativeBundles = {}
-}
-
-type InternalProps = { mode?: 'dev' | 'prod'; assetsDest?: string; useCache?: boolean }
-
-export async function getReactNativeBundle(
-  options: Pick<VXRNOptionsFilled, 'root'> &
-    Partial<Pick<VXRNOptionsFilled, 'cacheDir'>> &
-    Parameters<typeof getReactNativeBuildConfig>[0],
-  platform: 'ios' | 'android',
-  internal: InternalProps = {
-    mode: 'dev',
-    useCache: true,
-  }
-) {
-  entryRoot = options.root
-
-  const cached = cachedReactNativeBundles[platform]
-  if (cached && !process.env.VXRN_DISABLE_CACHE) {
-    return cached
-  }
-
-  await prebuildReactNativeModules(options.cacheDir || getCacheDir(options.root), {
-    // TODO: a better way to pass the mode (dev/prod) to PrebuiltReactModules
-    mode: internal.mode,
-  })
-
-  if (isBuildingNativeBundle) {
-    const res = await isBuildingNativeBundle
-    return res
-  }
-
-  let done
-  setIsBuildingNativeBundle(
-    new Promise((res) => {
-      done = res
-    })
-  )
-
-  // build app
-  const nativeBuildConfig = await getReactNativeBuildConfig(options, internal, platform)
-
-  nativeBuildConfig.plugins = filterPluginsForNative(nativeBuildConfig.plugins, {
-    isNative: true,
-  })
-
-  // instrument plugins:
-  const buildStats: Record<string, number> = {}
-  if (process.env.ONE_DEBUG_BUILD_PERF) {
-    nativeBuildConfig.plugins = nativeBuildConfig.plugins.map((plugin) => {
-      return new Proxy(plugin, {
-        get(target, key) {
-          const value = Reflect.get(target, key)
-          // wrap with instrumentation
-          if (typeof value === 'function') {
-            return function (this, ...args) {
-              const name = `${plugin.name}:${key as any}`
-              const start = performance.now()
-              const logEnd = () => {
-                buildStats[name] ||= 0
-                buildStats[name] += performance.now() - start
-              }
-              const out = value.call(this, ...args)
-              if (out instanceof Promise) {
-                return out
-                  .then((val) => {
-                    logEnd()
-                    return val
-                  })
-                  .catch((err) => {
-                    logEnd()
-                    throw err
-                  })
-              }
-              logEnd()
-              return out
-            }
-          }
-          return value
-        },
-      })
-    })
-  }
-
-  const builder = await createBuilder(nativeBuildConfig)
-
-  const environment = builder.environments[platform]
-
-  // We are using a forked version of the Vite internal function `buildEnvironment` (which is what `builder.build` calls) that will return the Rollup cache object with the build output, and also with some performance improvements.
-  // disabled due to differences in vite 6 stable upgrade
-
-  const buildOutput = await builder.build(environment)
-
-  if (process.env.ONE_DEBUG_BUILD_PERF) {
-    console.info(JSON.stringify(buildStats, null, 2))
-  }
-
-  if (!('output' in buildOutput)) {
-    throw `❌`
-  }
-
-  let appCode = buildOutput.output
-    // entry last
-    .sort((a, b) => (a['isEntry'] ? 1 : a['fileName'].localeCompare(b['fileName']) + -2))
-    .map((outputModule) => {
-      const id = outputModule.fileName.replace(/.*node_modules\//, '')
-
-      if (outputModule.type == 'chunk') {
-        const importsMap = {}
-        for (const imp of outputModule.imports) {
-          const relativePath = relative(dirname(id), imp)
-          importsMap[relativePath[0] === '.' ? relativePath : './' + relativePath] =
-            imp.replace(/.*node_modules\//, '')
-        }
-
-        let code = outputModule.code
-
-        // A hacky way to exclude node-fetch from the bundle.
-        //
-        // Some part of Supabase SDK will import node-fetch statically (https://github.com/supabase/supabase-js/blob/v2.45.1/src/lib/fetch.ts#L2), or dynamically (https://github.com/supabase/auth-js/blob/8222ee198a0ab10570e8b4c31ffb2aeafef86392/src/lib/helpers.ts#L99), causing the node-fetch to be included in the bundle, and while imported statically it will throw a runtime error when running on React Native.
-        if (outputModule.facadeModuleId?.includes('@supabase/node-fetch')) {
-          // This should be safe since the imported '@supabase/node-fetch' will not actually be used in Supabase SDK as there's already a global `fetch` in React Native.
-          code = ''
-        }
-
-        if (id.startsWith('.vxrn/react-native')) {
-          // Turn eager imports of RN back into dynamic lazy imports.
-          // We needed them eager so rollup won't be unhappy with missing exports, but now we need them lazy again to match the original RN behavior, which may avoid some issues. Such as:
-          // * react-native v0.76 with: Codegen didn't run for RNCSafeAreaView. This will be an error in the future. Make sure you are using @react-native/babel-preset when building your JavaScript code.
-          code = code
-            .replace(
-              // Step 1: Replace the whole `exports` block which contains `exports.REACT_NATIVE_ESM_MANUAL_EXPORTS_` with `module.exports = RN;`
-              /(^exports.+$\s)*(^exports\.REACT_NATIVE_ESM_MANUAL_EXPORTS_.+$\s)(^exports.+$\s)*/m,
-              'module.exports = RN;'
-            )
-            .replace(
-              // Step 2: Remove the variable assignment lines between the ESM_MANUAL_EXPORTS markers
-              // (inside __esmMin block). Must use `= "` anchor to avoid matching the __exportAll
-              // object keys which use `: () =>` syntax.
-              /^\tREACT_NATIVE_ESM_MANUAL_EXPORTS_START = "[\s\S]*?REACT_NATIVE_ESM_MANUAL_EXPORTS_END = ".*$/m,
-              ''
-            )
-        }
-
-        return `
-// id: ${id}
-// name: ${outputModule.name}
-// facadeModuleId: ${outputModule.facadeModuleId}
-// fileName: ${outputModule.fileName}
-___vxrnAbsoluteToRelative___["${outputModule.facadeModuleId}"] = "${id}"
-___modules___["${id}"] = ((exports, module) => {
-const require = createRequire("${id}", ${JSON.stringify(importsMap, null, 2)})
-
-${code}
-})
-
-${
-  outputModule.isEntry
-    ? `
-// run entry
-const __require = createRequire(":root:", {})
-globalThis.ReactNative = __require("react-native")
-globalThis.React = __require("react")
-__require("${id}")
-`
-    : ''
-}
-`
-      }
-    })
-    .join('\n')
-
-  if (!appCode) {
-    throw `❌`
-  }
-
-  appCode = appCode
-    // TEMP FIX for router tamagui thing since expo router 3 upgrade
-    .replaceAll('dist/esm/index.mjs"', 'dist/esm/index.js"')
-
-  const template = (await getReactNativeTemplate(internal.mode || 'dev')).replaceAll(
-    '__VXRN_PLATFORM__',
-    `"${platform}"`
-  )
-
-  const out = template + appCode
-
-  cachedReactNativeBundles[platform] = out
-  done(out)
-  setIsBuildingNativeBundle(null)
-
-  return out
-}
-
-/**
- * Get `react-native-template.js` with some `process.env.*` replaced with static values.
- */
-async function getReactNativeTemplate(mode: 'dev' | 'prod') {
-  const templateFile = resolvePath('vxrn/react-native-template.js')
-  let template = await readFile(templateFile, 'utf-8')
-
-  template = template.replace(/process\.env\.__DEV__/g, mode === 'dev' ? 'true' : 'false')
-
-  if (mode === 'prod') {
-    // `process` might not available in release runtime
-    template = template.replace(/process\.env\.DEBUG/g, 'undefined')
-
-    // In production mode, the prebuilt modules have `.production` in their filenames
-    template = template.replaceAll(
-      '.vxrn/react-jsx-runtime.js',
-      '.vxrn/react-jsx-runtime.production.js'
-    )
-    template = template.replaceAll('.vxrn/react.js', '.vxrn/react.production.js')
-    // react-native already has platform in filename, need to add .production before platform
-    template = template.replace(
-      /\.vxrn\/react-native\.(\$\{__VXRN_PLATFORM__\.toLowerCase\(\)\})\.js/g,
-      '.vxrn/react-native.production.$1.js'
-    )
-  }
-
-  return template
-}

package/src/utils/hotUpdateCache.ts

@@ -1 +0,0 @@
-export const hotUpdateCache = new Map<string, string>()

package/src/utils/isBuildingNativeBundle.ts

@@ -1,7 +0,0 @@
-// sorry for the mess, exploring before abstracting
-
-export let isBuildingNativeBundle: Promise<string> | null = null
-
-export function setIsBuildingNativeBundle(val: Promise<string> | null = null) {
-  isBuildingNativeBundle = val
-}

package/src/utils/swapPrebuiltReactModules.ts

@@ -1,341 +0,0 @@
-import { buildReact, buildReactJSX, buildReactNative } from '@vxrn/react-native-prebuilt'
-import { resolvePath } from '@vxrn/resolve'
-import FSExtra from 'fs-extra'
-import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import type { Plugin } from 'vite'
-import { isNativeEnvironment } from './environmentUtils'
-
-// Lock to prevent concurrent prebuilds which cause race conditions
-let prebuildPromise: Promise<void> | null = null
-
-// we should just detect or whitelist and use flow to convert instead of this but i did a
-// few things to the prebuilts to make them work, we may need to account for
-
-const getPrebuilds = (cacheDir: string, mode) => ({
-  reactJSX: join(cacheDir, `react-jsx-runtime${mode === 'prod' ? '.production' : ''}.js`),
-  react: join(cacheDir, `react${mode === 'prod' ? '.production' : ''}.js`),
-  reactNativeIos: join(
-    cacheDir,
-    `react-native${mode === 'prod' ? '.production' : ''}.ios.js`
-  ),
-  reactNativeAndroid: join(
-    cacheDir,
-    `react-native${mode === 'prod' ? '.production' : ''}.android.js`
-  ),
-})
-
-const allExist = async (paths: string[]) => {
-  return (await Promise.all(paths.map((p) => FSExtra.pathExists(p)))).every(Boolean)
-}
-
-export async function prebuildReactNativeModules(
-  cacheDir: string,
-  internal: { mode?: 'dev' | 'prod' } = { mode: 'dev' }
-) {
-  // If a prebuild is already in progress, wait for it and return
-  if (prebuildPromise) {
-    await prebuildPromise
-    return
-  }
-
-  const prebuilds = getPrebuilds(cacheDir, internal.mode)
-
-  // Set lock immediately before any async operation to prevent race conditions
-  let resolveLock: () => void
-  prebuildPromise = new Promise((resolve) => {
-    resolveLock = resolve
-  })
-
-  try {
-    if (
-      internal.mode !== 'prod' && // Do not use cached prebuilds while building for production, since the performance gain is little (build time is already slower anyway) and can avoid potential issues.
-      (await allExist(Object.values(prebuilds)))
-    ) {
-      return
-    }
-
-    if (internal.mode !== 'prod') {
-      console.info('\n ❶ Pre-building react-native (one time cost)...\n')
-    } else {
-      console.info('\n ❶ Pre-building react-native for production...\n')
-    }
-
-    /** Some build option overrides depending on the mode (dev/prod). */
-    const buildOptions =
-      internal.mode === 'prod'
-        ? {
-            define: {
-              __DEV__: 'false',
-              'process.env.NODE_ENV': `"production"`,
-            },
-          }
-        : {}
-
-    let enableExperimentalReactNativeWithReact19Support = false
-    const reactPackageJsonPath = resolvePath('react/package.json')
-    const reactPackageJsonContents = await readFile(reactPackageJsonPath, 'utf8')
-    const reactPackageJson = JSON.parse(reactPackageJsonContents)
-    const reactNativePackageJsonPath = resolvePath('react/package.json')
-    const reactNativePackageJsonContents = await readFile(
-      reactNativePackageJsonPath,
-      'utf8'
-    )
-    const reactNativePackageJson = JSON.parse(reactNativePackageJsonContents)
-
-    const reactVersion = reactPackageJson?.version
-    const reactNativeVersion = reactNativePackageJson?.version
-    if (reactVersion?.startsWith('19') && Number.parseFloat(reactNativeVersion) < 0.78) {
-      console.info(
-        `🧪 React ${reactVersion} detected. Enabling experimental React 19 support for React Native.`
-      )
-      enableExperimentalReactNativeWithReact19Support = true
-    }
-
-    await Promise.all([
-      buildReactNative(
-        {
-          entryPoints: [resolvePath('react-native')],
-          outfile: prebuilds.reactNativeIos,
-          ...buildOptions,
-        },
-        { platform: 'ios', enableExperimentalReactNativeWithReact19Support }
-      ).catch((err) => {
-        console.error(`Error pre-building react-native for iOS`)
-        throw err
-      }),
-      buildReactNative(
-        {
-          entryPoints: [resolvePath('react-native')],
-          outfile: prebuilds.reactNativeAndroid,
-          ...buildOptions,
-        },
-        { platform: 'android', enableExperimentalReactNativeWithReact19Support }
-      ).catch((err) => {
-        console.error(`Error pre-building react-native for Android`)
-        throw err
-      }),
-      buildReact({
-        entryPoints: [resolvePath('react')],
-        outfile: prebuilds.react,
-        ...buildOptions,
-      }).catch((err) => {
-        console.error(`Error pre-building react`)
-        throw err
-      }),
-      buildReactJSX({
-        entryPoints: [
-          internal.mode === 'dev'
-            ? resolvePath('react/jsx-dev-runtime')
-            : resolvePath('react/jsx-runtime'),
-        ],
-        outfile: prebuilds.reactJSX,
-        ...buildOptions,
-      }).catch((err) => {
-        console.error(`Error pre-building react/jsx-runtime`)
-        throw err
-      }),
-    ])
-  } finally {
-    // Release the lock so other callers can proceed
-    resolveLock!()
-    prebuildPromise = null
-  }
-}
-
-export async function swapPrebuiltReactModules(
-  cacheDir: string,
-  internal: { mode: 'dev' | 'prod'; platform: 'ios' | 'android' }
-): Promise<Plugin> {
-  let prebuilds = getPrebuilds(cacheDir, internal.mode)
-
-  let cached: null | Record<
-    | 'react-native'
-    | 'react'
-    | 'react/jsx-runtime'
-    | 'react/jsx-dev-runtime'
-    | 'react/jsx-runtime',
-    {
-      alias: string
-      contents: string
-    }
-  > = null
-
-  const rnPrebuilt = (() => {
-    switch (internal.platform) {
-      case 'ios':
-        return prebuilds.reactNativeIos
-      case 'android':
-        return prebuilds.reactNativeAndroid
-      default:
-        throw new Error(`Unsupported platform: ${internal.platform}`)
-    }
-  })()
-
-  const getVirtualModules = async () => {
-    if (cached) return cached
-
-    const jsxRuntime = {
-      alias: prebuilds.reactJSX,
-      contents: await readFile(prebuilds.reactJSX, 'utf-8'),
-    } as const
-
-    cached = {
-      'react-native': {
-        alias: rnPrebuilt,
-        contents: await readFile(rnPrebuilt, 'utf-8'),
-      },
-      react: {
-        alias: prebuilds.react,
-        contents: await readFile(prebuilds.react, 'utf-8'),
-      },
-      'react/jsx-runtime': jsxRuntime,
-      'react/jsx-dev-runtime': jsxRuntime,
-    } as const
-
-    return cached
-  }
-
-  const virtualModules = await getVirtualModules()
-
-  const cachedIdToContents = Object.keys(virtualModules).reduce((acc, key) => {
-    const cur = virtualModules[key]
-    acc[cur.alias] = cur.contents
-    return acc
-  }, {})
-
-  return {
-    name: `swap-react-native`,
-    enforce: 'pre',
-
-    async resolveId(id, _importer, options) {
-      // Skip during Vite's dependency optimization scan
-      // @see https://github.com/remix-run/remix/discussions/8917
-      // @ts-expect-error - scan is not in Vite's types but exists at runtime
-      if (options?.scan) return
-
-      if (!isNativeEnvironment(this.environment)) {
-        return
-      }
-
-      if (id === 'react-native-web') {
-        return rnPrebuilt
-      }
-
-      if (id.startsWith('react-native/')) {
-        if (id === 'react-native/package.json') {
-          return
-        }
-        return `virtual:rn-internals:${id}`
-      }
-
-      // We might have aliased `react-native` to `react-native-web` (see `'react-native': 'react-native-web'` in `utils/getBaseViteConfig.ts`) so we need to handle that case too.
-      if (
-        id.startsWith('react-native-web/Libraries') ||
-        id.includes('react-native-web/dist/cjs/index.js/Libraries') // Possible after switched to CJS (Tamagui 1.112.3)
-      ) {
-        return `virtual:rn-internals:${id.replace(/^.*react-native-web(\/dist\/cjs\/index.js)?/, 'react-native')}`
-      }
-
-      for (const targetId in virtualModules) {
-        if (id === targetId || id.includes(`/node_modules/${targetId}/`)) {
-          const info = virtualModules[targetId]
-          return info.alias
-        }
-      }
-    },
-
-    async load(id) {
-      if (id.startsWith('virtual:rn-internals')) {
-        const idOut = id.replace('virtual:rn-internals:', '')
-
-        let out = ''
-
-        if (id.includes('ReactFabric')) {
-          // A workaround for some internal modules being loaded when they shouldn't be.
-          // See: https://github.com/onejs/one/pull/283#issuecomment-2527356510
-          out += `const ___val = __cachedModules["${idOut}"] /* This module shouldn't be loaded if not already been loaded internally. */`
-        } else {
-          // Normal case, this will dynamically load the module if not already loaded.
-          out += `const ___val = __RN_INTERNAL_MODULE_REQUIRES_MAP__["${idOut}"]()`
-        }
-
-        out += '\n'
-
-        out += `
-        const ___defaultVal = ___val ? ___val.default || ___val : ___val
-        export default ___defaultVal
-        `
-
-        out += getReactNativeInternalModuleExports(idOut)
-          .map(
-            (exportName) =>
-              `export const ${exportName} = ___val.${exportName} || ___defaultVal.${exportName}`
-          )
-          .join('\n')
-
-        out += `
-        // allow importing named exports of internals:
-        if (___defaultVal && typeof ___defaultVal === 'object') {
-          Object.keys(___defaultVal).forEach(key => {
-            if (key !== 'default') {
-              exports[key] = ___defaultVal[key]
-            }
-          })
-        }
-        `
-
-        return out
-      }
-
-      if (id in cachedIdToContents) {
-        return cachedIdToContents[id]
-      }
-    },
-  } satisfies Plugin
-}
-
-/**
- * Given a React Native internal module path, return the list of export names that are exported from the module, excluding the default export.
- */
-function getReactNativeInternalModuleExports(
-  /**
-   * Example: `react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry`.
-   */
-  modulePath: string
-): string[] {
-  return KNOWN_REACT_NATIVE_INTERNAL_MODULE_EXPORTS[modulePath] || []
-}
-
-/**
- * TODO: We can use `es-module-lexer` to parse from source code instead of hardcoding these.
- * Keywords: `"..." is not exported by "virtual:rn-internals:react-native/..."`
- */
-const KNOWN_REACT_NATIVE_INTERNAL_MODULE_EXPORTS = {
-  'react-native/Libraries/NativeComponent/NativeComponentRegistry': [
-    'setRuntimeConfigProvider',
-    'get',
-    'getWithFallback_DEPRECATED',
-    'unstable_hasStaticViewConfig',
-  ],
-  'react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry': [
-    'customBubblingEventTypes',
-    'customDirectEventTypes',
-    'register',
-    'get',
-  ],
-  'react-native/Libraries/Pressability/PressabilityDebug': [
-    'PressabilityDebugView',
-    'isEnabled',
-    'setEnabled',
-  ],
-  'react-native/Libraries/Utilities/PolyfillFunctions': [
-    'polyfillObjectProperty',
-    'polyfillGlobal',
-  ],
-  'react-native/Libraries/Image/resolveAssetSource': [
-    'pickScale',
-    'setCustomSourceTransformer',
-    'addCustomSourceTransformer',
-  ],
-}

package/src/worker.ts

@@ -1,90 +0,0 @@
-import { parentPort, isMainThread, Worker } from 'node:worker_threads'
-import type { VXRNOptionsFilled } from './config/getOptionsFilled'
-import { loadEnv } from './exports/loadEnv'
-import { getReactNativeBundle } from './utils/getReactNativeBundle'
-import { resolvePath } from '@vxrn/resolve'
-import {
-  type ConfigSubset,
-  getResolvedConfig,
-  setResolvedConfig,
-} from './plugins/getResolvedConfigSubset'
-
-type WorkerCommands = {
-  name: 'bundle-react-native'
-  arg: {
-    options: Pick<VXRNOptionsFilled, 'root'> &
-      Partial<Pick<VXRNOptionsFilled, 'cacheDir'>> &
-      Parameters<typeof getReactNativeBundle>[0]
-    platform: 'ios' | 'android'
-  }
-  returns: string
-}
-
-const workerPath = resolvePath('vxrn/worker')
-
-let worker: Worker
-
-export function runOnWorker<Command extends WorkerCommands>(
-  name: Command['name'],
-  arg: Command['arg']
-): Promise<Command['returns']> {
-  console.info(`RUN`, name)
-
-  worker ||= new Worker(workerPath, {
-    stdout: true,
-    stderr: true,
-  })
-
-  return new Promise((resolve, reject) => {
-    worker.postMessage({ name, arg, _resolvedConfig: getResolvedConfig() })
-
-    worker.on('message', (message: any) => {
-      if (message.result) {
-        resolve(message.result)
-      } else if (message.error) {
-        reject(new Error(message.error))
-      }
-    })
-
-    worker.on('error', (error) => {
-      reject(error)
-    })
-
-    worker.on('exit', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Worker stopped with exit code ${code}`))
-      }
-    })
-  })
-}
-
-process.on('exit', () => {
-  worker?.terminate()
-})
-
-if (!isMainThread && parentPort) {
-  parentPort.on(
-    'message',
-    async (message: WorkerCommands & { _resolvedConfig: ConfigSubset }) => {
-      if (message._resolvedConfig) {
-        setResolvedConfig(message._resolvedConfig)
-      }
-
-      switch (message.name) {
-        case 'bundle-react-native': {
-          const { options, platform } = message.arg
-
-          try {
-            loadEnv('development')
-            const bundle = await getReactNativeBundle(options, platform, { mode: 'dev' })
-            parentPort!.postMessage({ result: bundle })
-          } catch (error: any) {
-            parentPort!.postMessage({ error: error.message })
-          }
-
-          break
-        }
-      }
-    }
-  )
-}