@vxrn/compiler 2.0.0-beta.33.1 → 2.0.0-beta.362.1

package/src/transformBabel.ts

@@ -1,4 +1,5 @@
-import { extname, relative } from 'node:path'
+import { existsSync, readFileSync } from 'node:fs'
+import { extname, join } from 'node:path'
 // type-only, so that importing this module does not drag babel in. every metro
 // worker loads it through the package index, and on the native transform path
 // babel is never called at all: loading it there is pure startup cost.
@@ -13,6 +14,38 @@ type Props = GetTransformProps & {
   userSetting?: GetTransformResponse
 }
 
+const USER_BABEL_CONFIG_FILES = [
+  'babel.config.js',
+  'babel.config.cjs',
+  'babel.config.mjs',
+  'babel.config.json',
+  '.babelrc',
+  '.babelrc.js',
+  '.babelrc.json',
+] as const
+
+// matches ONE_GENERATED_MARKER in one/src/cli/generateBundlerConfig.ts
+const ONE_GENERATED_MARKER = '@one/generated bundler-config'
+
+export function findUserBabelConfig(projectRoot?: string): string | null {
+  if (!projectRoot) return null
+  for (const name of USER_BABEL_CONFIG_FILES) {
+    const fullPath = join(projectRoot, name)
+    if (existsSync(fullPath)) {
+      try {
+        const content = readFileSync(fullPath, 'utf8')
+        if (content.includes(ONE_GENERATED_MARKER)) {
+          continue
+        }
+      } catch {
+        continue
+      }
+      return fullPath
+    }
+  }
+  return null
+}
+
 export function getBabelOptions(props: Props): babel.TransformOptions | null {
   // unify caller contracts (the Vite plugin hands POSIX ids; the native/patches
   // path hands OS-native ids) so every path matcher below can assume forward
@@ -20,22 +53,50 @@ export function getBabelOptions(props: Props): babel.TransformOptions | null {
   // reason. without it, RN's own files aren't matched on Windows.
   props = { ...props, id: normalizePath(props.id.split('?')[0]) }
 
+  const isProjectFile = !props.id.includes('node_modules')
+  const userBabelConfig =
+    isProjectFile && props.projectRoot ? findUserBabelConfig(props.projectRoot) : null
+
   if (props.userSetting === 'babel') {
-    return getOptions(props, true)
+    return getOptions(props, true, userBabelConfig)
   }
   if (
     typeof props.userSetting === 'undefined' ||
     (typeof props.userSetting === 'object' && props.userSetting.transform === 'babel')
   ) {
     if (props.userSetting?.excludeDefaultPlugins) {
-      return props.userSetting
+      return {
+        caller: getBabelCaller(props),
+        ...props.userSetting,
+        ...(userBabelConfig ? { configFile: userBabelConfig, babelrc: true } : {}),
+      }
     }
-    return getOptions(props)
+    return getOptions(props, false, userBabelConfig)
+  }
+  // an explicit per-file opt-out of babel survives a user config. without
+  // this, merely adding babel.config.js flips swc/oxc files to babel.
+  const userSetting = props.userSetting
+  if (
+    userSetting === 'swc' ||
+    userSetting === 'oxc' ||
+    userSetting === false ||
+    (typeof userSetting === 'object' &&
+      userSetting !== null &&
+      (userSetting.transform === 'swc' || userSetting.transform === 'oxc'))
+  ) {
+    return null
+  }
+  if (userBabelConfig) {
+    return getOptions(props, false, userBabelConfig)
   }
   return null
 }
 
-const getOptions = (props: Props, force = false): babel.TransformOptions | null => {
+const getOptions = (
+  props: Props,
+  force = false,
+  userBabelConfig: string | null = null
+): babel.TransformOptions | null => {
   let plugins: babel.PluginItem[] = []
 
   if (force || shouldBabelGenerators(props)) {
@@ -56,29 +117,37 @@ const getOptions = (props: Props, force = false): babel.TransformOptions | null
     }
   }
 
-  if (enableNativewind || shouldBabelReanimated(props)) {
-    try {
-      const workletsPlugin = resolvePath(
-        'react-native-worklets/plugin',
-        props.projectRoot
-      )
-      debug?.(`Using babel worklets on file ${props.id}`)
-      plugins.push(workletsPlugin)
-    } catch {}
-  }
-
   if (shouldBabelReactCompiler(props)) {
     debug?.(`Using babel react compiler on file`)
     plugins.push(getBabelReactCompilerPlugin(props))
   }
 
-  if (plugins.length) {
-    return { plugins }
+  if (plugins.length || userBabelConfig) {
+    return {
+      plugins,
+      caller: getBabelCaller(props),
+      ...(userBabelConfig ? { configFile: userBabelConfig, babelrc: true } : {}),
+    }
   }
 
   return null
 }
 
+function getBabelCaller(props: Props): babel.TransformOptions['caller'] {
+  // babel hands every caller field to presets (babel-preset-expo reads platform
+  // and isDev), but its types list only the esm support flags, so the extra
+  // fields go through a named value rather than a checked literal.
+  const caller = {
+    name: 'vxrn',
+    platform:
+      props.environment === 'ios' || props.environment === 'android'
+        ? props.environment
+        : 'web',
+    isDev: props.development,
+  }
+  return caller
+}
+
 /**
  * Run the react compiler through oxc's rust port instead of babel.
  *
@@ -91,14 +160,27 @@ const getOptions = (props: Props, force = false): babel.TransformOptions | null
 export async function transformOxcReactCompiler(
   id: string,
   code: string,
-  target: '18' | '19',
+  optionsOrTarget: '18' | '19' | (Record<string, any> & { target?: '18' | '19' }) = '19',
   sourceMap = false
 ) {
   const { transform } = await import('oxc-transform-react')
+  const compilerOptions =
+    typeof optionsOrTarget === 'string'
+      ? { target: optionsOrTarget }
+      : optionsOrTarget || {}
+
+  const target = compilerOptions.target ?? '19'
   const result = await transform(id, code, {
     jsx: 'preserve',
     sourcemap: sourceMap,
-    reactCompiler: { target },
+    reactCompiler: {
+      target,
+      ...compilerOptions,
+      environment: {
+        enableCustomTypeDefinitionForReanimated: true,
+        ...compilerOptions.environment,
+      },
+    },
   })
 
   // `errors` with fatal:false are react compiler BAILOUTS ("Cannot access refs
@@ -119,7 +201,10 @@ export async function transformOxcReactCompiler(
     )
   }
 
-  return { code: result.code, map: sourceMap ? (result.map as any) : undefined }
+  return {
+    code: result.code,
+    map: sourceMap ? (result.map as any) : undefined,
+  }
 }
 
 /**
@@ -137,14 +222,30 @@ export async function transformBabel(
   const extension = extname(id)
   const isTSX = extension === '.tsx'
   const isTS = isTSX || extension === '.ts'
-  const babelOptions = {
+  const babelOptions: babel.TransformOptions = {
     filename: id,
     compact: false,
-    babelrc: false,
-    configFile: false,
+    babelrc: options.babelrc ?? false,
+    configFile: options.configFile ?? false,
     sourceMaps: false,
     minified: false,
     ...options,
+    ...(!isTS
+      ? {
+          parserOpts: {
+            ...options.parserOpts,
+            plugins: [...(options.parserOpts?.plugins || []), 'jsx'],
+          },
+        }
+      : {}),
+    // vite and rolldown own module syntax and import.meta, so presets written for
+    // metro (babel-preset-expo) must keep esm instead of rewriting it for metro's runtime
+    caller: {
+      name: 'vxrn',
+      ...options.caller,
+      supportsStaticESM: true,
+      supportsDynamicImport: true,
+    },
     presets: [
       isTS
         ? [
@@ -168,7 +269,10 @@ export async function transformBabel(
     plugins: [
       ...(isTS
         ? []
-        : [[hermesParserPlugin, { parseLangTypes: 'flow', reactRuntimeTarget: '19' }]]),
+        : [
+            [hermesParserPlugin, { parseLangTypes: 'flow', reactRuntimeTarget: '19' }],
+            'babel-plugin-transform-flow-enums',
+          ]),
       ...(options.plugins || []),
       ...(isTS ? [] : ['@babel/plugin-transform-flow-strip-types']),
     ],
@@ -184,6 +288,14 @@ export async function transformBabel(
   })
 }
 
+export async function stripFlowTypes(id: string, code: string, sourceMaps = true) {
+  const result = await transformBabel(id, code, { sourceMaps })
+  return {
+    code: result.code!,
+    map: result.map,
+  }
+}
+
 const getBasePlugins = ({ development }: Props) =>
   [
     ['@babel/plugin-transform-destructuring'],
@@ -294,74 +406,3 @@ function shouldBabelGenerators({ code }: Props) {
     return asyncGeneratorRegex.test(code)
   }
 }
-
-/**
- * ------- reanimated --------
- */
-
-/**
- * Taken from https://github.com/software-mansion/react-native-reanimated/blob/3.15.1/packages/react-native-reanimated/plugin/src/autoworkletization.ts#L19-L59, need to check if this is up-to-date when supporting newer versions of react-native-reanimated.
- */
-const REANIMATED_AUTOWORKLETIZATION_KEYWORDS = [
-  'worklet',
-  'useAnimatedGestureHandler',
-  'useAnimatedScrollHandler',
-  'useFrameCallback',
-  'useAnimatedStyle',
-  'useAnimatedProps',
-  'createAnimatedPropAdapter',
-  'useDerivedValue',
-  'useAnimatedReaction',
-  'useWorkletCallback',
-  'withTiming',
-  'withSpring',
-  'withDecay',
-  'withRepeat',
-  'runOnUI',
-  'executeOnUIRuntimeSync',
-]
-
-/**
- * Regex to test if a piece of code should be processed by react-native-reanimated's Babel plugin.
- */
-const REANIMATED_REGEX = new RegExp(REANIMATED_AUTOWORKLETIZATION_KEYWORDS.join('|'))
-
-// Packages to skip for reanimated babel transform
-// These either have false positives (mention keywords but don't use worklets)
-// or cause issues when transformed
-const REANIMATED_IGNORED_PATHS = [
-  // Prebuilt/vendored react-native that shouldn't be transformed
-  'react-native-prebuilt',
-  'node_modules/.vxrn/react-native',
-  // Known false positives - they mention worklet keywords in comments/strings but don't use them
-  'node_modules/react/',
-  'node_modules/react-dom/',
-  'node_modules/react-native/',
-  'node_modules/react-native-web/',
-]
-
-// `id`s are normalized to forward slashes at getBabelOptions' entry, so these
-// plain forward-slash paths match on every OS. before that normalization the
-// backslash `id`s Windows hands us slipped past this list, pushing react-native's
-// own files through the reanimated babel pass, which has no JSX/TS parser.
-const REANIMATED_IGNORED_PATHS_REGEX = new RegExp(REANIMATED_IGNORED_PATHS.join('|'))
-
-function shouldBabelReanimated({ code, id }: Props) {
-  if (!configuration.enableReanimated) {
-    return false
-  }
-
-  // Check if path should be ignored
-  if (REANIMATED_IGNORED_PATHS_REGEX.test(id)) {
-    return false
-  }
-
-  // Check regex for all files (both node_modules and user code)
-  if (REANIMATED_REGEX.test(code)) {
-    const location = id.includes('node_modules') ? 'node_modules' : 'user-code'
-    debug?.(` 🪄 [reanimated/${location}] ${relative(process.cwd(), id)}`)
-    return true
-  }
-
-  return false
-}

package/src/transformHermesClasses.ts

@@ -0,0 +1,34 @@
+// Hermes before V1 cannot parse ES6 classes. Oxc lowers fields but has an
+// ES2015 target floor, so classes and lexical bindings need Babel afterward.
+export async function transformHermesClasses(
+  code: string,
+  filename: string,
+  sourceMaps = false
+): Promise<{ code: string; map?: any } | undefined> {
+  if (!/\b(?:class(?:\s|\{)|(?:let|const)\s)/.test(code)) return
+  const [
+    { transformAsync },
+    { default: transformClasses },
+    { default: transformBlockScoping },
+  ] = await Promise.all([
+    import('@babel/core'),
+    import('@babel/plugin-transform-classes'),
+    import('@babel/plugin-transform-block-scoping'),
+  ])
+  const result = await transformAsync(code, {
+    filename,
+    babelrc: false,
+    configFile: false,
+    sourceMaps,
+    // the caller composes stage maps itself; a file's own sourceMappingURL
+    // composed here would give the stage map several sources
+    // @ts-expect-error @types/babel__core omits false, which babel accepts
+    inputSourceMap: false,
+    parserOpts: { plugins: ['jsx'] },
+    // Legacy Hermes hoists lexical names, including in class-free functions.
+    // Lower block scope so minification cannot shadow parameters or constructors.
+    plugins: [transformClasses, transformBlockScoping],
+  })
+  if (!result?.code) return
+  return { code: result.code, map: result.map }
+}

package/src/transformSWC.ts

@@ -22,7 +22,18 @@ export function shouldStripFlow(id: string, code: string): boolean {
   const header =
     code.match(/^(?:#![^\r\n]*(?:\r?\n|$))?(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\r\n]*)*/)?.[0] ||
     ''
-  return /@flow\b/.test(header) || /\b(?:import|export)\s+type\b/.test(code)
+  return (
+    /@flow\b/.test(header) ||
+    /\b(?:import|export)\s+type\b/.test(code) ||
+    // Some published Flow sources omit the pragma and use ordinary imports.
+    // Typed function returns, declarations, and class fields still need stripping.
+    /\(\s*(?:\.\.\.)?[\w$]+\??\s*:\s*/.test(code) ||
+    /\)\s*:\s*(?:[\w$]+(?:<[^;{}]*>)?(?:\[\])?\s*)(?:=>|\{)/.test(code) ||
+    /^\s*[\w$]+\??\s*:\s*(?:string|number|boolean|any|mixed|void|[A-Z][\w$]*)(?:[^;\r\n=]*)(?:=[^;\r\n]*)?;/m.test(
+      code
+    ) ||
+    /\b(?:opaque\s+)?type\s+[\w$]+(?:\s*<[^;{}]*>)?\s*=/.test(code)
+  )
 }
 
 export async function transformSWC(

package/src/transformWorklets.test.ts

@@ -1,6 +1,8 @@
 import fs from 'node:fs'
 import os from 'node:os'
+import { createRequire } from 'node:module'
 import path from 'node:path'
+import { runInNewContext } from 'node:vm'
 import { afterEach, describe, expect, it } from 'vitest'
 import { configureVXRNCompilerPlugin } from './configure'
 import { shouldTransformWorklets, transformWorklets } from './transformWorklets'
@@ -64,6 +66,11 @@ describe('transformWorklets', () => {
     expect(result.code).toContain('__initData')
     expect(result.code).toContain('__closure')
     expect(result.map).toBeUndefined()
+    const serialized = result.code.match(/code: ("(?:\\.|[^"\\])*")/)?.[1]
+    expect(serialized, 'serialized worklet code').toBeTruthy()
+    const worklet = (0, eval)(JSON.parse(serialized!))
+    expect(worklet).toBeTypeOf('function')
+    expect(worklet()).toBe(42)
   })
 
   it('ignores calls whose callee name collides with Object.prototype', async () => {
@@ -136,7 +143,7 @@ describe('transformWorklets', () => {
     `
     const result = await transformWorklets('/app/handler.ts', code, false)
     expect(result.code).toContain('__workletHash')
-    expect(result.code).toMatch(/code: "function _worklet\(e\)/)
+    expect(result.code).toMatch(/code: "\(function _worklet\(e\)/)
     expect(result.code).toContain('var _worklet = function _worklet(e)')
   })
 
@@ -162,12 +169,38 @@ describe('transformWorklets', () => {
     const result = await transformWorklets('/app/setupLoop.ts', code, false)
 
     expect(result.code).toMatch(/setupLoop\.__closure = \{\s*\}/)
-    const init = result.code.match(/code: "function setupLoop[^"]*"/)
+    const init = result.code.match(/code: "\(function setupLoop[^"]*"/)
     expect(init, 'serialized worklet code').toBeTruthy()
     expect(init![0]).not.toContain('this.__closure')
     expect(init![0]).toContain('flushQueue')
   })
 
+  it('keeps Reanimated UI-runtime globals out of the JavaScript closure', async () => {
+    const result = await transformWorklets(
+      '/app/valueUnpacker.ts',
+      `function valueUnpacker(value) { 'worklet'; return _toString(value) }
+       globalThis.__unpacker = valueUnpacker`,
+      false,
+      { pluginVersion: '3.19.1' }
+    )
+    const mainRuntime: any = {}
+    runInNewContext(result.code, mainRuntime)
+    expect(Object.keys(mainRuntime.__unpacker.__closure)).toEqual([])
+    const uiRuntime: any = { _toString: String }
+    const unpack = runInNewContext(mainRuntime.__unpacker.__initData.code, uiRuntime)
+    expect(unpack(42)).toBe('42')
+  })
+
+  it('keeps strict global configuration explicit for UI-runtime helpers', async () => {
+    const result = await transformWorklets(
+      '/app/strictGlobals.ts',
+      `function unpack(value) { 'worklet'; return _toString(value) }`,
+      false,
+      { pluginVersion: '3.19.1', strictGlobal: true }
+    )
+    expect(result.code).toMatch(/__closure = \{\s*_toString/)
+  })
+
   it('honors no-worklet-closure and limit-init-data-hoisting the way the worklets runtime needs', async () => {
     // this is the shape react-native-worklets uses for its unpacker installers.
     // the outer worklet is serialized to a string and evaluated on a worklet
@@ -190,7 +223,7 @@ describe('transformWorklets', () => {
     `
     const result = await transformWorklets('/app/installUnpacker.ts', code, false)
 
-    const outerInit = result.code.match(/code: "function installUnpacker[^"]*"/)
+    const outerInit = result.code.match(/code: "\(function installUnpacker[^"]*"/)
     expect(outerInit, 'outer worklet serialized code').toBeTruthy()
     // no unpacker line: nothing is read off `this` on the worklet runtime.
     expect(outerInit![0]).not.toContain('this.__closure')
@@ -201,7 +234,7 @@ describe('transformWorklets', () => {
     // the inner worklet's init data is declared inside the outer function body,
     // not hoisted to module scope where the worklet runtime cannot see it.
     const innerVar = result.code.match(
-      /var (_worklet_\d+_init_data) = \{\s*code: "function _worklet/
+      /var (_worklet_\d+_init_data) = \{\s*code: "\(function _worklet/
     )
     expect(innerVar, 'inner worklet init data').toBeTruthy()
     // only look past the serialized string, which mentions the same name inside
@@ -381,7 +414,12 @@ describe('transformWorklets', () => {
     expect(typeof scaleFn).toBe('function')
     expect(scaleFn.__workletHash).toBeDefined()
     expect(typeof scaleFn.__workletHash).toBe('number')
-    expect(scaleFn.__pluginVersion).toBe('0.10.1')
+    // /app has no package.json, so the stamp comes from the worklets runtime
+    // this workspace actually installs
+    const installedWorklets = createRequire(path.resolve(process.cwd(), 'package.json'))(
+      'react-native-worklets/package.json'
+    ).version
+    expect(scaleFn.__pluginVersion).toBe(installedWorklets)
     expect(scaleFn.__closure).toEqual({ multiplier: 5 })
     expect(scaleFn.__initData).toBeDefined()
     expect(scaleFn.__initData.code).toContain('__closure')
@@ -613,6 +651,43 @@ describe('transformWorklets', () => {
     expect(uiRes).toBe(7)
   })
 
+  it('captures the outer binding a property worklet shares its key with', async () => {
+    // react-native-gesture-handler's NativeProxy: the property worklet calls the
+    // module-level host function of the same name. naming the worklet after its
+    // key made it capture itself, so serializing its closure never ended.
+    const code = `
+      const updateConfig = (tag) => tag * 2
+      export const proxy = {
+        updateConfig: (tag) => {
+          'worklet'
+          return updateConfig(tag)
+        },
+        flush: function (tag) {
+          'worklet'
+          return updateConfig(tag) + 1
+        },
+      }
+    `
+    const result = await transformWorklets('/app/proxy.ts', code, false)
+
+    const sandbox = { global: globalThis, exports: {} as any }
+    const runner = new Function(
+      'exports',
+      'global',
+      result.code.replace('export const proxy', 'exports.proxy')
+    )
+    runner(sandbox.exports, sandbox.global)
+    const { proxy } = sandbox.exports
+
+    for (const worklet of [proxy.updateConfig, proxy.flush]) {
+      expect(worklet.__closure.updateConfig).not.toBe(worklet)
+      const reconstructed = eval(`(${worklet.__initData.code})`)
+      expect(reconstructed.call({ __closure: worklet.__closure }, 3)).toBe(worklet(3))
+    }
+    expect(proxy.updateConfig(3)).toBe(6)
+    expect(proxy.flush(3)).toBe(7)
+  })
+
   it('transforms nested worklets with bottom-up composition', async () => {
     const code = `
       export function outer() {

package/src/workletUtils.ts

@@ -0,0 +1,4 @@
+// compiler hosts can load capture analysis without importing Vite.
+export { getClosureVariables } from './worklets/scope'
+export { JS_GLOBALS } from './worklets/globals'
+export { transformHermesLoops } from './transformHermesLoops'

package/src/worklets/autoworklet.ts

@@ -306,7 +306,10 @@ export function findWorkletCandidates(program: any): WorkletCandidate[] {
             : fn.type === 'ArrowFunctionExpression'
               ? 'arrow_function'
               : 'function_expression',
-          name: node.key?.name,
+          // only a method is named by its key, as upstream's plugin does: a
+          // property's function has no binding of that name, so naming it would
+          // shadow an outer binding it closes over with the worklet itself.
+          name: node.method ? node.key?.name : fn.id?.name,
           parent,
           isAutoWorklet: false,
         })
@@ -368,7 +371,7 @@ export function findWorkletCandidates(program: any): WorkletCandidate[] {
                       prop.value.type === 'ArrowFunctionExpression'
                         ? 'arrow_function'
                         : 'function_expression',
-                    name: prop.key?.name,
+                    name: prop.value.id?.name,
                     parent: prop,
                     isAutoWorklet: true,
                   })

package/src/worklets/globals.ts

@@ -108,6 +108,29 @@ export const DEFAULT_GLOBALS = new Set([
   'clearInterval',
   'HermesInternal',
   '_WORKLET',
+  // Reanimated installs these in the UI runtime. Capturing them on the JS
+  // thread fails before its value unpacker can initialize (Reanimated 3).
+  'ReanimatedError',
+  '__reanimatedLoggerConfig',
+  '_IS_FABRIC',
+  '_log',
+  '_toString',
+  '_scheduleHostFunctionOnJS',
+  '_scheduleRemoteFunctionOnJS',
+  '_scheduleOnRuntime',
+  '_makeShareableClone',
+  '_updatePropsPaper',
+  '_updatePropsFabric',
+  '_measurePaper',
+  '_measureFabric',
+  '_scrollToPaper',
+  '_dispatchCommandPaper',
+  '_dispatchCommandFabric',
+  '_setGestureState',
+  '_notifyAboutProgress',
+  '_notifyAboutEnd',
+  '_runOnUIQueue',
+  '_getAnimationTimestamp',
 ])
 
 export function createGlobalsSet(

package/src/worklets/serialize.ts

@@ -64,7 +64,7 @@ export function serializeWorkletForUI(
 
   const transformed = transformSync('worklet.ts', fullFn)
   assertTransformed(transformed, name, 'serialized')
-  return transformed.code.trim()
+  return `(${transformed.code.trim().replace(/;$/, '')})`
 }
 
 /**

package/types/cache.d.ts

@@ -4,14 +4,14 @@ interface CacheStats {
     writes: 0;
     errors: 0;
 }
-export declare function getCachedTransform(filePath: string, code: string, environment: string): {
+export declare function getCachedTransform(filePath: string, code: string, environment: string, userBabelConfigPath?: string | null): {
     code: string;
     map?: any;
 } | null;
 export declare function setCachedTransform(filePath: string, code: string, result: {
     code: string;
     map?: any;
-}, environment: string): void;
+}, environment: string, userBabelConfigPath?: string | null): void;
 /** Drop every cached transform, for `react-native bundle --reset-cache`. */
 export declare function clearTransformCache(): void;
 export declare function getCacheStats(): CacheStats;

package/types/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AA4BA,UAAU,UAAU;IAClB,IAAI,EAAE,CAAC,CAAA;IACP,MAAM,EAAE,CAAC,CAAA;IACT,MAAM,EAAE,CAAC,CAAA;IACT,MAAM,EAAE,CAAC,CAAA;CACV;AAiDD,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,CAoCpC;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,EACnC,WAAW,EAAE,MAAM,GAClB,IAAI,CAwBN;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,aAAa,IAAI,UAAU,CAE1C;AAED,wBAAgB,aAAa,IAAI,IAAI,CAapC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AA4BA,UAAU,UAAU;IAClB,IAAI,EAAE,CAAC,CAAA;IACP,MAAM,EAAE,CAAC,CAAA;IACT,MAAM,EAAE,CAAC,CAAA;IACT,MAAM,EAAE,CAAC,CAAA;CACV;AA6ED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,CAoCpC;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,EACnC,WAAW,EAAE,MAAM,EACnB,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,GAClC,IAAI,CAwBN;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,aAAa,IAAI,UAAU,CAE1C;AAED,wBAAgB,aAAa,IAAI,IAAI,CAapC"}

package/types/index.d.ts

@@ -12,6 +12,7 @@ export * from './transformWorklets';
 export * from './reactNativeCodegen';
 export * from './transformHermesLoops';
 export * from './transformHermesAsync';
+export * from './transformHermesClasses';
 export { clearTransformCache } from './cache';
 export { JS_GLOBALS } from './worklets/globals';
 export { getClosureVariables } from './worklets/scope';

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,YAAY,EAA8B,MAAM,MAAM,CAAA;AAcpE,OAAO,KAAK,EAAkC,OAAO,EAAE,MAAM,SAAS,CAAA;AAGtE,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AACtD,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AA2R3C,wBAAsB,wBAAwB,CAC5C,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAC3B,OAAO,CAAC,YAAY,EAAE,CAAC,CA6VzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,YAAY,EAA8B,MAAM,MAAM,CAAA;AAcpE,OAAO,KAAK,EAAkC,OAAO,EAAE,MAAM,SAAS,CAAA;AAGtE,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AACtD,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AA8S3C,wBAAsB,wBAAwB,CAC5C,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAC3B,OAAO,CAAC,YAAY,EAAE,CAAC,CAkWzB"}

package/types/reactNativeViewConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactNativeViewConfig.d.ts","sourceRoot":"","sources":["../src/reactNativeViewConfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA4dH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,GAAG,CAuBnF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,GAAG,GACX;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAsE5C;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,UAEjF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIvD"}
+{"version":3,"file":"reactNativeViewConfig.d.ts","sourceRoot":"","sources":["../src/reactNativeViewConfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAieH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,GAAG,CAuBnF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,GAAG,GACX;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAsE5C;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,UAEjF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIvD"}

package/types/transformBabel.d.ts

@@ -3,6 +3,7 @@ import type { GetTransformProps, GetTransformResponse } from './types';
 type Props = GetTransformProps & {
     userSetting?: GetTransformResponse;
 };
+export declare function findUserBabelConfig(projectRoot?: string): string | null;
 export declare function getBabelOptions(props: Props): babel.TransformOptions | null;
 /**
  * Run the react compiler through oxc's rust port instead of babel.
@@ -13,7 +14,9 @@ export declare function getBabelOptions(props: Props): babel.TransformOptions |
  * still applies the project's jsxImportSource and dev-mode settings, exactly
  * as it did when babel only stripped types here.
  */
-export declare function transformOxcReactCompiler(id: string, code: string, target: '18' | '19', sourceMap?: boolean): Promise<{
+export declare function transformOxcReactCompiler(id: string, code: string, optionsOrTarget?: '18' | '19' | (Record<string, any> & {
+    target?: '18' | '19';
+}), sourceMap?: boolean): Promise<{
     code: string;
     map: any;
 }>;
@@ -21,5 +24,17 @@ export declare function transformOxcReactCompiler(id: string, code: string, targ
  * Transform input to mostly ES5 compatible code, keep ESM syntax, and transform generators.
  */
 export declare function transformBabel(id: string, code: string, options: babel.TransformOptions): Promise<babel.BabelFileResult>;
+export declare function stripFlowTypes(id: string, code: string, sourceMaps?: boolean): Promise<{
+    code: string;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+        mappings: string;
+        file: string;
+    } | null | undefined;
+}>;
 export {};
 //# sourceMappingURL=transformBabel.d.ts.map