@vxrn/compiler 1.25.16 → 1.26.0

package/src/worklets/hash.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic hash algorithm matching Reanimated / React Native Worklets.
+ */
+export function calculateWorkletHash(str: string): number {
+  let i = str.length
+  let hash1 = 5381
+  let hash2 = 52711
+  while (i--) {
+    const char = str.charCodeAt(i)
+    hash1 = (hash1 * 33) ^ char
+    hash2 = (hash2 * 33) ^ char
+  }
+  return (hash1 >>> 0) * 4096 + (hash2 >>> 0)
+}

package/src/worklets/scope.ts

@@ -0,0 +1,401 @@
+/**
+ * Lexical scope analysis and free variable capture for worklets.
+ * Builds an authentic lexical scope tree to correctly handle variable shadowing,
+ * block scoping (let/const), function hoisting, and catch parameters.
+ */
+
+interface ScopeFrame {
+  parent: ScopeFrame | null
+  isFunction: boolean
+  bindings: Set<string> // block-scoped declarations (let, const, class, params, catch)
+  varBindings: Set<string> // function-scoped declarations (var, top-level function declarations)
+}
+
+export function getClosureVariables(fnNode: any, globals: Set<string>): string[] {
+  const rootScope: ScopeFrame = {
+    parent: null,
+    isFunction: true,
+    bindings: new Set<string>(),
+    varBindings: new Set<string>(),
+  }
+
+  let currentScope: ScopeFrame = rootScope
+  const freeVariables = new Set<string>()
+
+  // Function name itself if named (in recursive worklets, fn can refer to itself)
+  if (fnNode.id && fnNode.id.name) {
+    rootScope.bindings.add(fnNode.id.name)
+  }
+
+  function pushScope(isFunction: boolean): ScopeFrame {
+    const newScope: ScopeFrame = {
+      parent: currentScope,
+      isFunction,
+      bindings: new Set<string>(),
+      varBindings: isFunction ? new Set<string>() : currentScope.varBindings,
+    }
+    currentScope = newScope
+    return newScope
+  }
+
+  function popScope() {
+    if (currentScope.parent) {
+      currentScope = currentScope.parent
+    }
+  }
+
+  function addBindings(pattern: any, targetSet: Set<string>) {
+    if (!pattern) return
+    switch (pattern.type) {
+      case 'Identifier':
+        targetSet.add(pattern.name)
+        break
+      case 'AssignmentPattern':
+        addBindings(pattern.left, targetSet)
+        walk(pattern.right)
+        break
+      case 'RestElement':
+        addBindings(pattern.argument, targetSet)
+        break
+      case 'ArrayPattern':
+        for (const el of pattern.elements) {
+          if (el) addBindings(el, targetSet)
+        }
+        break
+      case 'ObjectPattern':
+        for (const prop of pattern.properties) {
+          if (prop.type === 'Property') {
+            if (prop.computed) walk(prop.key)
+            addBindings(prop.value, targetSet)
+          } else if (prop.type === 'RestElement') {
+            addBindings(prop.argument, targetSet)
+          }
+        }
+        break
+    }
+  }
+
+  // same as addBindings but never walks a default value, so hoisting cannot
+  // resolve an identifier before the scope's declarations are all known.
+  function addBindingsOnly(pattern: any, targetSet: Set<string>) {
+    if (!pattern) return
+    switch (pattern.type) {
+      case 'Identifier':
+        targetSet.add(pattern.name)
+        break
+      case 'AssignmentPattern':
+        addBindingsOnly(pattern.left, targetSet)
+        break
+      case 'RestElement':
+        addBindingsOnly(pattern.argument, targetSet)
+        break
+      case 'ArrayPattern':
+        for (const el of pattern.elements) {
+          if (el) addBindingsOnly(el, targetSet)
+        }
+        break
+      case 'ObjectPattern':
+        for (const prop of pattern.properties) {
+          if (prop.type === 'Property') {
+            addBindingsOnly(prop.value, targetSet)
+          } else if (prop.type === 'RestElement') {
+            addBindingsOnly(prop.argument, targetSet)
+          }
+        }
+        break
+    }
+  }
+
+  /**
+   * Declarations a scope already has before its first statement runs: functions,
+   * classes and let/const at this level, plus `var` from anywhere below that is
+   * not inside a nested function. Without this a name used before its
+   * declaration, which hoisting makes legal, looks like a captured variable and
+   * ends up in the worklet's closure, where it does not exist.
+   */
+  function hoistDeclarations(node: any, direct: boolean) {
+    if (!node || typeof node !== 'object' || typeof node.type !== 'string') return
+    switch (node.type) {
+      case 'FunctionDeclaration':
+        if (node.id?.name) {
+          currentScope.bindings.add(node.id.name)
+          currentScope.varBindings.add(node.id.name)
+        }
+        return
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+        return
+      case 'ClassDeclaration':
+        if (direct && node.id?.name) currentScope.bindings.add(node.id.name)
+        return
+      case 'VariableDeclaration':
+        if (node.kind === 'var') {
+          for (const d of node.declarations) addBindingsOnly(d.id, currentScope.varBindings)
+        } else if (direct) {
+          for (const d of node.declarations) addBindingsOnly(d.id, currentScope.bindings)
+        }
+        return
+      case 'ExportNamedDeclaration':
+      case 'ExportDefaultDeclaration':
+        hoistDeclarations(node.declaration, direct)
+        return
+    }
+    for (const key of Object.keys(node)) {
+      if (key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue
+      const child = node[key]
+      if (Array.isArray(child)) {
+        for (const item of child) hoistDeclarations(item, false)
+      } else if (child && typeof child === 'object') {
+        hoistDeclarations(child, false)
+      }
+    }
+  }
+
+  // Parameters belong to the root function scope
+  if (fnNode.params) {
+    for (const param of fnNode.params) {
+      addBindings(param, rootScope.bindings)
+    }
+  }
+
+  function isDeclaredInScopes(name: string, fromScope: ScopeFrame): boolean {
+    let s: ScopeFrame | null = fromScope
+    while (s) {
+      if (s.bindings.has(name) || s.varBindings.has(name)) {
+        return true
+      }
+      s = s.parent
+    }
+    return false
+  }
+
+  function resolveIdentifier(name: string) {
+    if (!isDeclaredInScopes(name, currentScope) && !globals.has(name)) {
+      freeVariables.add(name)
+    }
+  }
+
+  function walk(node: any) {
+    if (!node || typeof node !== 'object') return
+
+    // Skip TypeScript type annotations entirely
+    if (
+      node.type === 'TSTypeAnnotation' ||
+      node.type === 'TSTypeReference' ||
+      node.type === 'TSTypeAliasDeclaration' ||
+      node.type === 'TSInterfaceDeclaration' ||
+      node.type === 'TSTypeParameterDeclaration' ||
+      node.type === 'TSTypeParameterInstantiation' ||
+      node.type === 'TSTypeQuery' ||
+      node.type === 'TSQualifiedName'
+    ) {
+      return
+    }
+
+    // TS type wrapper expressions: only walk the runtime expression
+    if (
+      node.type === 'TSAsExpression' ||
+      node.type === 'TSSatisfiesExpression' ||
+      node.type === 'TSTypeAssertion' ||
+      node.type === 'TSNonNullExpression' ||
+      node.type === 'TSInstantiationExpression'
+    ) {
+      walk(node.expression)
+      return
+    }
+
+    switch (node.type) {
+      case 'BlockStatement': {
+        const isRootBody = node === fnNode.body
+        if (!isRootBody) {
+          pushScope(false)
+        }
+        for (const stmt of node.body) {
+          hoistDeclarations(stmt, true)
+        }
+        for (const stmt of node.body) {
+          walk(stmt)
+        }
+        if (!isRootBody) {
+          popScope()
+        }
+        return
+      }
+
+      case 'VariableDeclaration': {
+        const isVar = node.kind === 'var'
+        const targetSet = isVar ? currentScope.varBindings : currentScope.bindings
+        for (const decl of node.declarations) {
+          addBindings(decl.id, targetSet)
+          if (decl.init) walk(decl.init)
+        }
+        return
+      }
+
+      case 'FunctionDeclaration':
+      case 'FunctionExpression': {
+        if (node.id && node.id.name) {
+          currentScope.bindings.add(node.id.name)
+        }
+        pushScope(true)
+        if (node.params) {
+          for (const param of node.params) {
+            addBindings(param, currentScope.bindings)
+          }
+        }
+        walk(node.body)
+        popScope()
+        return
+      }
+
+      case 'ArrowFunctionExpression': {
+        pushScope(true)
+        if (node.params) {
+          for (const param of node.params) {
+            addBindings(param, currentScope.bindings)
+          }
+        }
+        walk(node.body)
+        popScope()
+        return
+      }
+
+      case 'CatchClause': {
+        pushScope(false)
+        if (node.param) {
+          addBindings(node.param, currentScope.bindings)
+        }
+        walk(node.body)
+        popScope()
+        return
+      }
+
+      case 'ForStatement': {
+        pushScope(false)
+        if (node.init) walk(node.init)
+        if (node.test) walk(node.test)
+        if (node.update) walk(node.update)
+        walk(node.body)
+        popScope()
+        return
+      }
+
+      case 'ForInStatement':
+      case 'ForOfStatement': {
+        pushScope(false)
+        walk(node.left)
+        walk(node.right)
+        walk(node.body)
+        popScope()
+        return
+      }
+
+      case 'ClassDeclaration':
+      case 'ClassExpression': {
+        if (node.id && node.id.name) {
+          currentScope.bindings.add(node.id.name)
+        }
+        if (node.superClass) walk(node.superClass)
+        pushScope(false)
+        walk(node.body)
+        popScope()
+        return
+      }
+
+      case 'MemberExpression': {
+        walk(node.object)
+        if (node.computed) {
+          walk(node.property)
+        }
+        return
+      }
+
+      case 'Property': {
+        if (node.computed) {
+          walk(node.key)
+        }
+        walk(node.value)
+        return
+      }
+
+      case 'MethodDefinition': {
+        if (node.computed) {
+          walk(node.key)
+        }
+        walk(node.value)
+        return
+      }
+
+      case 'Identifier': {
+        resolveIdentifier(node.name)
+        return
+      }
+
+      case 'JSXElement': {
+        if (node.openingElement) {
+          const nameNode = node.openingElement.name
+          if (nameNode.type === 'JSXIdentifier') {
+            if (/^[A-Z]/.test(nameNode.name)) {
+              resolveIdentifier(nameNode.name)
+            }
+          } else if (nameNode.type === 'JSXMemberExpression') {
+            let root = nameNode.object
+            while (root.type === 'JSXMemberExpression') {
+              root = root.object
+            }
+            if (root.type === 'JSXIdentifier') {
+              resolveIdentifier(root.name)
+            }
+          }
+          if (node.openingElement.attributes) {
+            for (const attr of node.openingElement.attributes) {
+              walk(attr)
+            }
+          }
+        }
+        if (node.children) {
+          for (const child of node.children) {
+            walk(child)
+          }
+        }
+        return
+      }
+
+      case 'JSXAttribute': {
+        if (node.value) {
+          walk(node.value)
+        }
+        return
+      }
+
+      case 'JSXExpressionContainer': {
+        walk(node.expression)
+        return
+      }
+
+      case 'BreakStatement':
+      case 'ContinueStatement':
+      case 'LabeledStatement': {
+        if (node.body) walk(node.body)
+        return
+      }
+    }
+
+    // Default recursive traversal
+    for (const key of Object.keys(node)) {
+      if (key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue
+      const child = node[key]
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          walk(item)
+        }
+      } else if (child && typeof child === 'object') {
+        walk(child)
+      }
+    }
+  }
+
+  walk(fnNode.body)
+
+  return Array.from(freeVariables).sort()
+}

package/src/worklets/serialize.ts

@@ -0,0 +1,114 @@
+import { transformSync } from 'oxc-transform'
+import { bodyStartAfterDirectives } from './autoworklet'
+
+/**
+ * oxc returns empty code plus errors rather than throwing, and an empty
+ * `__initData.code` only fails much later on a worklet runtime with a message
+ * that names none of this. So refuse to emit one.
+ */
+function assertTransformed(
+  transformed: { code: string; errors?: any[] },
+  name: string | undefined,
+  what: string
+) {
+  const error = transformed.errors?.[0]
+  if (error) {
+    throw new Error(
+      `[worklets] failed to build ${what} code for ${name || 'anonymous worklet'}: ${error.message || error}`
+    )
+  }
+  if (!transformed.code.trim()) {
+    throw new Error(
+      `[worklets] built empty ${what} code for ${name || 'anonymous worklet'}`
+    )
+  }
+}
+
+/**
+ * Serializes a worklet function into a string for the Hermes UI thread (__initData.code).
+ * Includes injected unpacker: `const { var1, var2 } = this.__closure ?? this._closure;`
+ * Strips TypeScript types and formats via oxc-transform.
+ */
+export function serializeWorkletForUI(
+  fnNode: any,
+  code: string,
+  name: string | undefined,
+  closureVars: string[]
+): string {
+  let rawParams = ''
+  if (fnNode.params && fnNode.params.length > 0) {
+    const pStart = fnNode.params[0].start
+    const pEnd = fnNode.params[fnNode.params.length - 1].end
+    rawParams = code.slice(pStart, pEnd)
+  }
+
+  let rawBody = ''
+  if (fnNode.body.type === 'BlockStatement') {
+    const bodyStart = bodyStartAfterDirectives(fnNode, code)
+    const bodyEnd = fnNode.body.end - 1
+    rawBody = code.slice(bodyStart, bodyEnd)
+  } else {
+    rawBody = `return ${code.slice(fnNode.body.start, fnNode.body.end)};`
+  }
+
+  const unpacker = closureVars.length > 0
+    ? `const { ${closureVars.join(', ')} } = this.__closure ?? this._closure;\n`
+    : ''
+
+  const asyncPrefix = fnNode.async ? 'async ' : ''
+  const genPrefix = fnNode.generator ? '*' : ''
+  const fnName = name || '_worklet'
+
+  const fullFn = `${asyncPrefix}function${genPrefix} ${fnName}(${rawParams}) {\n${unpacker}${rawBody}\n}`
+
+  const transformed = transformSync('worklet.ts', fullFn)
+  assertTransformed(transformed, name, 'serialized')
+  return transformed.code.trim()
+}
+
+/**
+ * Builds the local JavaScript function to run on the JS thread inside the worklet IIFE.
+ * Strips TypeScript types and the 'worklet' directive.
+ */
+export function buildLocalFunction(
+  fnNode: any,
+  code: string,
+  name: string | undefined
+): string {
+  let rawParams = ''
+  if (fnNode.params && fnNode.params.length > 0) {
+    const pStart = fnNode.params[0].start
+    const pEnd = fnNode.params[fnNode.params.length - 1].end
+    rawParams = code.slice(pStart, pEnd)
+  }
+
+  let rawBody = ''
+  if (fnNode.body.type === 'BlockStatement') {
+    const bodyStart = bodyStartAfterDirectives(fnNode, code)
+    const bodyEnd = fnNode.body.end - 1
+    rawBody = code.slice(bodyStart, bodyEnd)
+  } else {
+    rawBody = code.slice(fnNode.body.start, fnNode.body.end)
+  }
+
+  let rawFn = ''
+  const asyncPrefix = fnNode.async ? 'async ' : ''
+  const genPrefix = fnNode.generator ? '*' : ''
+
+  if (fnNode.type === 'ArrowFunctionExpression') {
+    if (fnNode.body.type === 'BlockStatement') {
+      rawFn = `${asyncPrefix}(${rawParams}) => {\n${rawBody}\n}`
+    } else {
+      rawFn = `${asyncPrefix}(${rawParams}) => (${rawBody})`
+    }
+  } else {
+    // an anonymous `function (x) {}` does not parse on its own, and this is
+    // emitted into `var <localName> = ...`, where a name binds only inside the
+    // function itself.
+    rawFn = `${asyncPrefix}function${genPrefix} ${name || '_worklet'}(${rawParams}) {\n${rawBody}\n}`
+  }
+
+  const transformed = transformSync('local.ts', rawFn)
+  assertTransformed(transformed, name, 'local')
+  return transformed.code.trim().replace(/;$/, '')
+}