@vxrn/compiler 2.0.0-beta.98.1 → 2.6.0

package/src/transformBabel.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs'
-import { extname, join, relative } from 'node:path'
+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.
@@ -66,6 +66,7 @@ export function getBabelOptions(props: Props): babel.TransformOptions | null {
   ) {
     if (props.userSetting?.excludeDefaultPlugins) {
       return {
+        caller: getBabelCaller(props),
         ...props.userSetting,
         ...(userBabelConfig ? { configFile: userBabelConfig, babelrc: true } : {}),
       }
@@ -116,17 +117,6 @@ const getOptions = (
     }
   }
 
-  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))
@@ -135,6 +125,7 @@ const getOptions = (
   if (plugins.length || userBabelConfig) {
     return {
       plugins,
+      caller: getBabelCaller(props),
       ...(userBabelConfig ? { configFile: userBabelConfig, babelrc: true } : {}),
     }
   }
@@ -142,6 +133,21 @@ const getOptions = (
   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.
  *
@@ -216,7 +222,7 @@ 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: options.babelrc ?? false,
@@ -224,10 +230,19 @@ export async function transformBabel(
     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,
     },
@@ -273,14 +288,6 @@ 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'],
@@ -391,74 +398,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/transformFlow.test.ts

@@ -0,0 +1,134 @@
+import { createRequire } from 'node:module'
+import { runInNewContext } from 'node:vm'
+import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping'
+import { parseSync } from 'oxc-parser'
+import { transformSync } from 'oxc-transform'
+import { describe, expect, it, vi } from 'vitest'
+import { transformBabel } from './transformBabel'
+import { stripFlowTypes } from './transformFlow'
+import { transformHermesClasses } from './transformHermesClasses'
+
+vi.mock('@babel/core', () => ({
+  default: {
+    transform() {
+      throw new Error('babel reached native transform')
+    },
+    transformAsync() {
+      throw new Error('babel reached native transform')
+    },
+  },
+}))
+
+const require = createRequire(import.meta.url)
+
+describe('native transforms preserve Flow runtime behavior without Babel', () => {
+  it('rejects the old Babel path as its negative control', async () => {
+    await expect(transformBabel('control.js', 'const value = 1', {})).rejects.toThrow(
+      'babel reached native transform'
+    )
+  })
+
+  it.each([
+    'enum State { Ready = 1, Busy = 2 }',
+    'enum State { Ready, Busy }',
+    'enum State of symbol { Ready, Busy }',
+    'enum State of boolean { Ready = true, Busy = false }',
+  ])(
+    'preserves enum methods, readonly types, defaults and mappings: %s',
+    async (enumSource) => {
+      const source = [
+        '// @flow',
+        'type Input = { readonly value: number };',
+        enumSource,
+        'function value(input: Input = {value: 42}): number {',
+        '  return input.value;',
+        '}',
+        'globalThis.result = { value: value(), State };',
+      ].join('\n')
+      const result = await stripFlowTypes('flow.js', source)
+      expect(parseSync('flow.js', result.code).errors).toEqual([])
+      const context: any = { require }
+      runInNewContext(result.code, context)
+      expect(context.result.value).toBe(42)
+      const { State } = context.result
+      expect(State.isValid(State.Ready)).toBe(true)
+      expect(State.isValid('invalid')).toBe(false)
+      expect(State.cast(State.Busy)).toBe(State.Busy)
+      expect(State.getName(State.Ready)).toBe('Ready')
+      expect(Array.from(State.members())).toEqual([State.Ready, State.Busy])
+      expect(Object.keys(State)).toEqual([])
+      expect(Object.isFrozen(State)).toBe(true)
+      const lines = result.code.split('\n')
+      const line = lines.findIndex((text) => text.includes('input.value'))
+      const position = originalPositionFor(new TraceMap(result.map), {
+        line: line + 1,
+        column: lines[line].indexOf('input.value'),
+      })
+      expect(position.source).toBe('flow.js')
+      expect(position.line).toBe(5)
+      expect(result.map.sourcesContent).toEqual([source])
+    }
+  )
+
+  it('retains named and default enum exports and JSX for the native bundler', async () => {
+    for (const prefix of ['export', 'export default']) {
+      const result = await stripFlowTypes(
+        'View.js',
+        `${prefix} enum State {Ready, Busy}
+         export function View(props: {value: string}) { return <NativeView {...props} /> }`
+      )
+      expect(parseSync('View.jsx', result.code, { lang: 'jsx' }).errors).toEqual([])
+    }
+  })
+
+  it('erases Flow field declarations before Hermes class lowering to preserve prototype constants', async () => {
+    const source = `class Event {
+      static +NONE: 0;
+      +NONE: 0;
+      value: number = 42;
+    }
+    Object.defineProperty(Event, 'NONE', {value: 0});
+    Object.defineProperty(Event.prototype, 'NONE', {value: 0});
+    globalThis.result = new Event();
+    globalThis.Event = Event;`
+    const stripped = await stripFlowTypes('Event.js', source)
+    const fields = transformSync('Event.js', stripped.code, {
+      target: 'es2020',
+      assumptions: { setPublicClassFields: true },
+    })
+    expect(fields.errors).toEqual([])
+    const lowered = await transformHermesClasses(fields.code, 'Event.js', true)
+    expect(lowered).toBeDefined()
+    const context: any = {}
+    runInNewContext(lowered!.code, context)
+    expect(context.result.NONE).toBe(0)
+    expect(context.Event.NONE).toBe(0)
+    expect(Object.hasOwn(context.result, 'NONE')).toBe(false)
+    expect(context.result.value).toBe(42)
+  })
+
+  it('lowers class hierarchies and parameter shadowing without Babel', async () => {
+    const result = await transformHermesClasses(
+      `class Base { value() { return 2 } }
+       class Derived extends Base {
+         constructor(value = 'default', ...rest) { super(); this.params = [value, ...rest] }
+         value() { return super.value() + 3 }
+       }
+       function read(config) { if (true) { const config = 7; globalThis.inner = config } return config.id }
+       globalThis.result = [new Derived().value(), read({id: 'device'})];
+       globalThis.params = new Derived(undefined, 'rest-a', 'rest-b').params;
+       globalThis.run = async (value = 2n) => await Promise.resolve(value);
+       globalThis.pending = globalThis.run();`,
+      'classes.js',
+      true
+    )
+    expect(result).toBeDefined()
+    const context: any = {}
+    runInNewContext(result!.code, context)
+    expect(Array.from(context.result)).toEqual([5, 'device'])
+    expect(context.inner).toBe(7)
+    expect(Array.from(context.params)).toEqual(['default', 'rest-a', 'rest-b'])
+    expect(await context.pending).toBe(2n)
+    expect(context.run.constructor.name).toBe('AsyncFunction')
+  })
+})

package/src/transformFlow.ts

@@ -0,0 +1,68 @@
+import remapping from '@jridgewell/remapping'
+import { generate } from 'astring'
+import { parse, SimpleTraverser, Transforms } from 'hermes-parser'
+import MagicString from 'magic-string'
+
+export async function stripFlowTypes(id: string, code: string, sourceMaps = true) {
+  // swc represents flow enums as typescript enums. hermes owns their distinct
+  // runtime semantics; lower only those declarations before native stripping.
+  const edited = new MagicString(code)
+  if (/\benum\b/.test(code)) {
+    const program = parse(code, { flow: 'all', sourceType: 'module' })
+    SimpleTraverser.traverse(program, {
+      enter(node, parent) {
+        if (node.type !== 'EnumDeclaration') return
+        const declaration = parent?.type === 'ExportDefaultDeclaration' ? parent : node
+        const [start, end] = declaration.range
+        const lowered = Transforms.transformEnumSyntax(
+          { ...program, body: [declaration] },
+          {}
+        )
+        edited.overwrite(start, end, generate(lowered).trimEnd())
+      },
+      leave() {},
+    })
+  }
+  const { transform } = await import('@swc/core')
+  const result = await transform(edited.toString(), {
+    filename: id,
+    swcrc: false,
+    configFile: false,
+    inputSourceMap: false,
+    sourceMaps,
+    jsc: {
+      target: 'esnext',
+      parser: {
+        syntax: 'flow',
+        all: true,
+        jsx: true,
+        enums: true,
+        components: true,
+        patternMatching: true,
+      },
+      // match Flow's declaration erasure before the native class-field pass.
+      transform: {
+        react: { runtime: 'preserve' },
+        useDefineForClassFields: false,
+      },
+    },
+  })
+  const map = result.map ? JSON.parse(result.map) : undefined
+  return {
+    code: result.code,
+    map:
+      map && edited.hasChanged()
+        ? remapping(
+            [
+              map,
+              edited.generateMap({
+                source: id,
+                includeContent: true,
+                hires: true,
+              }),
+            ],
+            () => null
+          )
+        : map,
+  }
+}

package/src/transformHermesClasses.ts

@@ -0,0 +1,34 @@
+// hermes before v1 cannot parse classes. swc lowers the complete hierarchy
+// together with lexical bindings after oxc's field and syntax transforms.
+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 { transform } = await import('@swc/core')
+  const result = await transform(code, {
+    filename,
+    swcrc: false,
+    configFile: false,
+    sourceMaps,
+    // the caller composes stage maps itself; a file's own sourceMappingURL
+    // composed here would give the stage map several sources
+    inputSourceMap: false,
+    isModule: 'unknown',
+    jsc: {
+      parser: { syntax: 'ecmascript', jsx: true },
+      transform: { react: { runtime: 'preserve' } },
+    },
+    // class lowering emits strict constructors, so their defaults and rest
+    // parameters must be lowered with them; async lowering belongs to its stage.
+    env: {
+      include: ['transform-classes', 'transform-block-scoping', 'transform-parameters'],
+    },
+  })
+  if (!result?.code) return
+  return {
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : undefined,
+  }
+}

package/src/transformSWC.test.ts

@@ -1,7 +1,39 @@
 import { describe, expect, it } from 'vitest'
 import { runInNewContext } from 'node:vm'
 import { rolldown } from 'rolldown'
-import { transformOxc, transformSWC, transformSWCStripJSX } from './transformSWC'
+import {
+  shouldStripFlow,
+  transformOxc,
+  transformSWC,
+  transformSWCStripJSX,
+} from './transformSWC'
+
+describe('Flow stripping keeps generated JavaScript on the native parser path', () => {
+  it.each([
+    [
+      '/app/node_modules/react-native/Libraries/Renderer/generated.js',
+      'module.exports = { value: 42 }',
+    ],
+    [
+      '/app/node_modules/react-devtools-core/backend.js',
+      'const label = "function value(x: string)"; module.exports = label',
+    ],
+    [
+      '/app/NativeView.js',
+      '/* @flow */ export function View() { return <NativeView /> }',
+    ],
+  ])('preserves JavaScript accepted by the native parser: %s', (id, code) => {
+    expect(shouldStripFlow(id!, code!)).toBe(false)
+  })
+
+  it.each([
+    'export function value(x: number): number { return x + 1 }',
+    'export type Value = { value: number }; export const value: Value = { value: 1 }',
+    'enum Status { Ready, Waiting }; export const ready = Status.Ready',
+  ])('retains stripping for actual Flow syntax: %s', (code) => {
+    expect(shouldStripFlow('/app/node_modules/react-native/Flow.js', code)).toBe(true)
+  })
+})
 
 describe('transformSWC / transformOxc with oxc-transform for Hermes lowering', () => {
   it('preserves unbraced for-await bodies and early returns', async () => {

package/src/transformSWC.ts

@@ -1,4 +1,5 @@
 import { extname } from 'node:path'
+import { parseSync } from 'oxc-parser'
 import { normalizePath } from 'vite'
 import { configuration } from './configure'
 import { asyncGeneratorRegex, debug, runtimePublicPath } from './constants'
@@ -15,14 +16,23 @@ const ignoreId = /node_modules\/(\.vite|vite)\//
 export function shouldStripFlow(id: string, code: string): boolean {
   const filename = id.split('?')[0]
   if (!/\.jsx?$/.test(filename)) return false
-  if (/node_modules[\\/](?:react-native|@react-native)[\\/].*\.js$/.test(filename)) {
-    return true
-  }
   // scan the complete comment preamble, including license blocks before @flow.
   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)
+  const candidate =
+    /node_modules[\\/](?:react-native|@react-native)[\\/].*\.js$/.test(filename) ||
+    /@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)
+  return candidate && parseSync(filename, code, { lang: 'jsx' }).errors.length > 0
 }
 
 export async function transformSWC(

package/src/transformWorklets.test.ts

@@ -2,6 +2,7 @@ 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'
@@ -174,6 +175,32 @@ describe('transformWorklets', () => {
     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
@@ -624,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/types/index.d.ts

@@ -7,11 +7,13 @@ import type { PluginOption } from 'vite';
 import type { Options } from './types';
 export * from './configure';
 export * from './transformBabel';
+export * from './transformFlow';
 export * from './transformSWC';
 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;AA0S3C,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,iBAAiB,CAAA;AAC/B,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

@@ -3,7 +3,7 @@
  *
  * `@react-native/codegen` builds a full CodegenSchema with @babel/parser and
  * emits the module with @babel/generator, which is the last thing in the native
- * pipeline that runs babel at all: 11,774 babel calls per bundle of the soot
+ * pipeline that runs babel at all: 11,774 babel calls per bundle of the contrast
  * app, every one of them from codegen. The view config itself is a plain object
  * literal, so it can be read off the spec's own AST and printed as text.
  *

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"}