@vxrn/compiler 2.13.3 → 2.13.5

package/src/worklets/classes.ts

@@ -0,0 +1,238 @@
+import type { WorkletClassCandidate } from './types'
+
+export const WORKLET_CLASS_MARKER = '__workletClass'
+export const WORKLET_CLASS_FACTORY_SUFFIX = '__classFactory'
+
+const MARKER_FIELD_TYPES = new Set([
+  'PropertyDefinition',
+  'AccessorProperty',
+  'TSAbstractPropertyDefinition',
+])
+
+function isMarkerField(element: any): boolean {
+  return (
+    MARKER_FIELD_TYPES.has(element?.type) &&
+    !element.computed &&
+    element.key?.type === 'Identifier' &&
+    element.key.name === WORKLET_CLASS_MARKER
+  )
+}
+
+export function findWorkletClasses(program: any): WorkletClassCandidate[] {
+  const candidates: WorkletClassCandidate[] = []
+
+  function walk(node: any, parent: any) {
+    if (!node || typeof node !== 'object') return
+
+    if (
+      node.type === 'ClassDeclaration' &&
+      node.id?.type === 'Identifier' &&
+      !node.declare &&
+      // class-level decorators sit outside the class range upstream's factory
+      // shape can carry, so decorated classes keep today's raw capture.
+      !(node.decorators?.length > 0)
+    ) {
+      const marker = node.body?.body?.find(isMarkerField)
+      if (marker) {
+        candidates.push({ node, name: node.id.name, parent, marker })
+      }
+    }
+
+    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, node)
+      } else if (child && typeof child === 'object') {
+        walk(child, node)
+      }
+    }
+  }
+
+  walk(program, null)
+  // a marked class nested inside another marked class shares one rewrite
+  // range with it, so only the outermost of an overlap is rewritten.
+  return candidates.filter(
+    (candidate) =>
+      !candidates.some(
+        (other) =>
+          other !== candidate &&
+          other.node.start <= candidate.node.start &&
+          other.node.end >= candidate.node.end
+      )
+  )
+}
+
+export function classFactoryName(className: string): string {
+  return `${className}${WORKLET_CLASS_FACTORY_SUFFIX}`
+}
+
+function collectPatternNames(pattern: any, count: (name: string) => void) {
+  if (!pattern || typeof pattern !== 'object') return
+  switch (pattern.type) {
+    case 'Identifier':
+      count(pattern.name)
+      return
+    case 'AssignmentPattern':
+      collectPatternNames(pattern.left, count)
+      return
+    case 'RestElement':
+      collectPatternNames(pattern.argument, count)
+      return
+    case 'ArrayPattern':
+      for (const element of pattern.elements ?? []) collectPatternNames(element, count)
+      return
+    case 'ObjectPattern':
+      for (const property of pattern.properties ?? []) {
+        if (property?.type === 'Property') collectPatternNames(property.value, count)
+        else if (property?.type === 'RestElement')
+          collectPatternNames(property.argument, count)
+      }
+      return
+    case 'TSParameterProperty':
+      collectPatternNames(pattern.parameter, count)
+      return
+  }
+}
+
+/**
+ * marked class names that are the sole value binding of that name in the file.
+ * every free reference to one necessarily resolves to the marked class, so a
+ * worklet capturing it (a superclass, a static access, an instanceof) carries
+ * the factory instead of the raw class. any other binding of the same name
+ * keeps the previous capture, since the reference may resolve to that one.
+ */
+export function findUnambiguousClassNames(
+  program: any,
+  candidates: WorkletClassCandidate[]
+): Set<string> {
+  const wanted = new Set(candidates.map((candidate) => candidate.name))
+  const counts = new Map<string, number>()
+  const count = (name: string) => {
+    if (wanted.has(name)) counts.set(name, (counts.get(name) ?? 0) + 1)
+  }
+
+  function walk(node: any) {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item)
+      return
+    }
+    switch (node.type) {
+      case 'VariableDeclarator':
+        collectPatternNames(node.id, count)
+        break
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+        if (node.id?.type === 'Identifier') count(node.id.name)
+        for (const param of node.params ?? []) collectPatternNames(param, count)
+        break
+      case 'ArrowFunctionExpression':
+        for (const param of node.params ?? []) collectPatternNames(param, count)
+        break
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        if (node.id?.type === 'Identifier') count(node.id.name)
+        break
+      case 'CatchClause':
+        collectPatternNames(node.param, count)
+        break
+      case 'ImportSpecifier':
+      case 'ImportDefaultSpecifier':
+      case 'ImportNamespaceSpecifier':
+        if (node.local?.type === 'Identifier') count(node.local.name)
+        break
+      case 'TSEnumDeclaration':
+      case 'TSModuleDeclaration':
+        if (node.id?.type === 'Identifier') count(node.id.name)
+        break
+    }
+    for (const key of Object.keys(node)) {
+      if (key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue
+      walk(node[key])
+    }
+  }
+
+  walk(program)
+  return new Set(
+    candidates.filter((candidate) => counts.get(candidate.name) === 1).map((c) => c.name)
+  )
+}
+
+const ABSTRACT_MEMBER_TYPES = new Set([
+  'TSAbstractMethodDefinition',
+  'TSAbstractPropertyDefinition',
+])
+
+export function buildClassFactoryDeclaration(
+  candidate: WorkletClassCandidate,
+  code: string
+): string {
+  const { node, name, marker } = candidate
+  const factory = classFactoryName(name)
+
+  // the marker plus any bodiless abstract member, which only compiles inside
+  // an abstract class declaration and a factory holds a class expression.
+  const removals: Array<[number, number]> = [
+    [marker.decorators?.[0]?.start ?? marker.start, marker.end],
+  ]
+  for (const element of node.body?.body ?? []) {
+    if (ABSTRACT_MEMBER_TYPES.has(element?.type)) {
+      removals.push([element.start, element.end])
+    }
+  }
+  removals.sort((a, b) => a[0] - b[0])
+  let classSrc = ''
+  let cursor = node.start
+  for (const [start, end] of removals) {
+    if (start < cursor) continue
+    classSrc += code.slice(cursor, start)
+    cursor = end
+  }
+  classSrc += code.slice(cursor, node.end)
+  const classExpr = classSrc.replace(/^abstract\s+/, '')
+
+  return [
+    `function ${factory}() {`,
+    `'worklet';`,
+    `const ${name} = ${classExpr};`,
+    `${name}.${factory} = ${factory};`,
+    `return ${name};`,
+    `}`,
+  ].join('\n')
+}
+
+/**
+ * names constructed with `new Name()` anywhere under the worklet, in traversal
+ * order. like upstream's plugin, callers rewrite one whose name is also a
+ * captured variable to its class factory, without checking where the class
+ * was defined, so imported worklet classes resolve through their own file.
+ */
+export function findConstructedNames(fnNode: any): string[] {
+  const names: string[] = []
+  const seen = new Set<string>()
+
+  function walk(node: any) {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item)
+      return
+    }
+    if (
+      node.type === 'NewExpression' &&
+      node.callee?.type === 'Identifier' &&
+      !seen.has(node.callee.name)
+    ) {
+      seen.add(node.callee.name)
+      names.push(node.callee.name)
+    }
+    for (const key of Object.keys(node)) {
+      if (key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue
+      walk(node[key])
+    }
+  }
+
+  walk(fnNode.body)
+  for (const param of fnNode.params ?? []) walk(param)
+  return names
+}

package/src/worklets/scope.ts

@@ -296,6 +296,9 @@ export function getClosureVariables(fnNode: any, globals: Set<string>): string[]
         if (node.id && node.id.name) {
           currentScope.bindings.add(node.id.name)
         }
+        if (node.decorators) {
+          for (const decorator of node.decorators) walk(decorator)
+        }
         if (node.superClass) walk(node.superClass)
         pushScope(false)
         walk(node.body)
@@ -319,14 +322,37 @@ export function getClosureVariables(fnNode: any, globals: Set<string>): string[]
         return
       }
 
-      case 'MethodDefinition': {
+      case 'MethodDefinition':
+      case 'TSAbstractMethodDefinition': {
         if (node.computed) {
           walk(node.key)
         }
+        if (node.decorators) {
+          for (const decorator of node.decorators) walk(decorator)
+        }
         walk(node.value)
         return
       }
 
+      case 'PropertyDefinition':
+      case 'AccessorProperty':
+      case 'TSAbstractPropertyDefinition': {
+        // a plain field name is not a value reference. without this case the
+        // default traversal captures every field name as a closure variable.
+        if (node.computed) {
+          walk(node.key)
+        }
+        if (node.decorators) {
+          for (const decorator of node.decorators) walk(decorator)
+        }
+        if (node.value) walk(node.value)
+        return
+      }
+
+      case 'TSIndexSignature': {
+        return
+      }
+
       case 'Identifier': {
         resolveIdentifier(node.name)
         return

package/src/worklets/serialize.ts

@@ -24,6 +24,11 @@ function assertTransformed(
   }
 }
 
+export type ClassReconstruction = {
+  name: string
+  factory: string
+}
+
 /**
  * serializes a worklet function into a string for the hermes ui thread (__initData.code).
  * includes injected unpacker: `const [var1, var2] = this.__closure;`
@@ -33,7 +38,8 @@ export function serializeWorkletForUI(
   fnNode: any,
   code: string,
   name: string | undefined,
-  closureVars: string[]
+  closureVars: string[],
+  reconstructions: ClassReconstruction[] = []
 ): string {
   let rawParams = ''
   if (fnNode.params && fnNode.params.length > 0) {
@@ -53,12 +59,18 @@ export function serializeWorkletForUI(
 
   const unpacker =
     closureVars.length > 0 ? `const [${closureVars.join(', ')}] = this.__closure;\n` : ''
+  const rebuilt =
+    reconstructions.length > 0
+      ? reconstructions
+          .map(({ name, factory }) => `const ${name} = ${factory}();\n`)
+          .join('')
+      : ''
 
   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 fullFn = `${asyncPrefix}function${genPrefix} ${fnName}(${rawParams}) {\n${unpacker}${rebuilt}${rawBody}\n}`
 
   const transformed = transformSync('worklet.ts', fullFn)
   assertTransformed(transformed, name, 'serialized')

package/src/worklets/transform.ts

@@ -7,10 +7,21 @@ import {
   findWorkletCandidates,
   hasDirective,
 } from './autoworklet'
+import {
+  buildClassFactoryDeclaration,
+  classFactoryName,
+  findConstructedNames,
+  findUnambiguousClassNames,
+  findWorkletClasses,
+} from './classes'
 import { createGlobalsSet } from './globals'
 import { calculateWorkletHash } from './hash'
 import { getClosureVariables } from './scope'
-import { buildLocalFunction, serializeWorkletForUI } from './serialize'
+import {
+  buildLocalFunction,
+  serializeWorkletForUI,
+  type ClassReconstruction,
+} from './serialize'
 import type { TransformWorkletsOptions } from './types'
 
 const FUNCTION_TYPES = new Set([
@@ -124,7 +135,17 @@ export function executeWorkletTransform(
   }
 
   const initialCandidates = findWorkletCandidates(initialParse.program)
-  if (initialCandidates.length === 0) {
+  // upstream's plugin skips class work under either flag, and this port has
+  // no bundle-mode support, so both leave classes and their captures raw.
+  const workletClassesEnabled = !options?.disableWorkletClasses && !options?.bundleMode
+  const initialClasses = workletClassesEnabled
+    ? findWorkletClasses(initialParse.program)
+    : []
+  const resolvableClassNames =
+    initialClasses.length > 0
+      ? findUnambiguousClassNames(initialParse.program, initialClasses)
+      : new Set<string>()
+  if (initialCandidates.length === 0 && initialClasses.length === 0) {
     let map: any = undefined
     if (sourceMaps) {
       const ms = new MagicString(code)
@@ -154,6 +175,48 @@ export function executeWorkletTransform(
   const initDataDefs = new Map<string, string>()
   const passMaps: any[] = []
 
+  // marked classes become serializable factories before the worklet passes, so
+  // the factories themselves are workletized like any other candidate and a
+  // worklet capturing the class reconstructs it from the factory on the ui
+  // thread instead of capturing the raw class.
+  if (initialClasses.length > 0) {
+    const ms = new MagicString(currentCode)
+    for (const candidate of initialClasses) {
+      const factoryDecl = buildClassFactoryDeclaration(candidate, currentCode)
+      const rebound = `const ${candidate.name} = ${classFactoryName(candidate.name)}();`
+      if (candidate.parent?.type === 'ExportNamedDeclaration') {
+        ms.overwrite(
+          candidate.parent.start,
+          candidate.parent.end,
+          `${factoryDecl}\nexport ${rebound}`
+        )
+      } else if (candidate.parent?.type === 'ExportDefaultDeclaration') {
+        ms.overwrite(
+          candidate.parent.start,
+          candidate.parent.end,
+          `${factoryDecl}\n${rebound}\nexport default ${candidate.name};`
+        )
+      } else {
+        ms.overwrite(
+          candidate.node.start,
+          candidate.node.end,
+          `${factoryDecl}\n${rebound}`
+        )
+      }
+    }
+    if (sourceMaps) {
+      passMaps.push(
+        ms.generateMap({
+          source: cleanId,
+          file: cleanId,
+          hires: true,
+          includeContent: true,
+        })
+      )
+    }
+    currentCode = ms.toString()
+  }
+
   // 3. Iterative bottom-up transformation
   // In each pass, we transform all innermost candidates (candidates that contain NO other candidates in their body).
   // All innermost candidates are disjoint, so they can be rewritten simultaneously in a single MagicString.
@@ -202,16 +265,42 @@ export function executeWorkletTransform(
       // `no-worklet-closure` says the worklet captures nothing, so it gets no
       // unpacker line and an empty `__closure`. it is what lets the worklets
       // runtime evaluate the serialized code with no closure to bind.
-      const closureVars = hasDirective(candidate.fnNode, 'no-worklet-closure')
+      let closureVars = hasDirective(candidate.fnNode, 'no-worklet-closure')
         ? []
         : getClosureVariables(candidate.fnNode, globals)
+      // a capture that is known to be a worklet class travels as its
+      // factory and is rebuilt from it on the ui thread, so a factory
+      // closing over its superclass stays serializable. anything else that
+      // is constructed resolves through its own file like upstream.
+      const reconstructions: ClassReconstruction[] = []
+      if (workletClassesEnabled && closureVars.length > 0) {
+        const captured = new Set(closureVars)
+        const rewriteToFactory = (name: string) => {
+          if (!captured.has(name)) return
+          const factory = classFactoryName(name)
+          captured.delete(name)
+          captured.add(factory)
+          if (!reconstructions.some((r) => r.factory === factory)) {
+            reconstructions.push({ name, factory })
+          }
+        }
+        const knownCaptures = [...captured].filter((name) =>
+          resolvableClassNames.has(name)
+        )
+        for (const name of knownCaptures) rewriteToFactory(name)
+        for (const constructed of findConstructedNames(candidate.fnNode)) {
+          rewriteToFactory(constructed)
+        }
+        closureVars = [...captured].sort()
+      }
       const fnName = candidate.name
 
       const serializedCode = serializeWorkletForUI(
         candidate.fnNode,
         currentCode,
         fnName,
-        closureVars
+        closureVars,
+        reconstructions
       )
       const workletHash = calculateWorkletHash(serializedCode)
       const initDataVar = `_worklet_${workletHash}_init_data`
@@ -242,7 +331,12 @@ export function executeWorkletTransform(
       const localFnCode = buildLocalFunction(candidate.fnNode, currentCode, fnName)
       const localName = fnName || '_worklet'
       // worklets 0.13 captures values in the same order the ui function unpacks them.
-      const closureValues = closureVars.join(', ')
+      // a class factory travels as a member of its class, which the defining
+      // file attached when it built the factory.
+      const factoryOwners = new Map(reconstructions.map((r) => [r.factory, r.name]))
+      const closureValues = closureVars
+        .map((v) => (factoryOwners.has(v) ? `${factoryOwners.get(v)}.${v}` : v))
+        .join(', ')
 
       const iife = `(function () {
     var _e = [new (typeof global !== 'undefined' ? global : globalThis).Error(), 1, -27];

package/src/worklets/types.ts

@@ -24,3 +24,10 @@ export interface WorkletCandidate {
   parent?: any
   isAutoWorklet: boolean
 }
+
+export interface WorkletClassCandidate {
+  node: any
+  name: string
+  parent?: any
+  marker: any
+}

package/types/transformWorklets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformWorklets.d.ts","sourceRoot":"","sources":["../src/transformWorklets.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sCAAsC,UAiBlD,CAAA;AAiCD,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,WAWjF;AAED,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CA8DlF;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAOD,OAAO,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAA;AAEtE,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,UAAU,UAAQ,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC,CAqBtC"}
+{"version":3,"file":"transformWorklets.d.ts","sourceRoot":"","sources":["../src/transformWorklets.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sCAAsC,UAqBlD,CAAA;AAiCD,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,WAWjF;AAED,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CA8DlF;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAOD,OAAO,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAA;AAEtE,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,UAAU,UAAQ,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC,CAqBtC"}

package/types/worklets/classes.d.ts

@@ -0,0 +1,22 @@
+import type { WorkletClassCandidate } from './types';
+export declare const WORKLET_CLASS_MARKER = "__workletClass";
+export declare const WORKLET_CLASS_FACTORY_SUFFIX = "__classFactory";
+export declare function findWorkletClasses(program: any): WorkletClassCandidate[];
+export declare function classFactoryName(className: string): string;
+/**
+ * marked class names that are the sole value binding of that name in the file.
+ * every free reference to one necessarily resolves to the marked class, so a
+ * worklet capturing it (a superclass, a static access, an instanceof) carries
+ * the factory instead of the raw class. any other binding of the same name
+ * keeps the previous capture, since the reference may resolve to that one.
+ */
+export declare function findUnambiguousClassNames(program: any, candidates: WorkletClassCandidate[]): Set<string>;
+export declare function buildClassFactoryDeclaration(candidate: WorkletClassCandidate, code: string): string;
+/**
+ * names constructed with `new Name()` anywhere under the worklet, in traversal
+ * order. like upstream's plugin, callers rewrite one whose name is also a
+ * captured variable to its class factory, without checking where the class
+ * was defined, so imported worklet classes resolve through their own file.
+ */
+export declare function findConstructedNames(fnNode: any): string[];
+//# sourceMappingURL=classes.d.ts.map

package/types/worklets/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../src/worklets/classes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,eAAO,MAAM,oBAAoB,mBAAmB,CAAA;AACpD,eAAO,MAAM,4BAA4B,mBAAmB,CAAA;AAiB5D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,GAAG,GAAG,qBAAqB,EAAE,CA2CxE;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AA8BD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,GAAG,EACZ,UAAU,EAAE,qBAAqB,EAAE,GAClC,GAAG,CAAC,MAAM,CAAC,CAoDb;AAOD,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,CAiCR;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE,CA2B1D"}

package/types/worklets/scope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/worklets/scope.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAoY/E"}
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/worklets/scope.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CA8Z/E"}

package/types/worklets/serialize.d.ts

@@ -1,9 +1,13 @@
+export type ClassReconstruction = {
+    name: string;
+    factory: string;
+};
 /**
  * serializes a worklet function into a string for the hermes ui thread (__initData.code).
  * includes injected unpacker: `const [var1, var2] = this.__closure;`
  * strips typescript types and formats via oxc-transform.
  */
-export declare function serializeWorkletForUI(fnNode: any, code: string, name: string | undefined, closureVars: string[]): string;
+export declare function serializeWorkletForUI(fnNode: any, code: string, name: string | undefined, closureVars: string[], reconstructions?: ClassReconstruction[]): string;
 /**
  * Builds the local JavaScript function to run on the JS thread inside the worklet IIFE.
  * Strips TypeScript types and the 'worklet' directive.

package/types/worklets/serialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/worklets/serialize.ts"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,WAAW,EAAE,MAAM,EAAE,GACpB,MAAM,CA6BR;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,CAqCR"}
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/worklets/serialize.ts"],"names":[],"mappings":"AA0BA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,WAAW,EAAE,MAAM,EAAE,EACrB,eAAe,GAAE,mBAAmB,EAAO,GAC1C,MAAM,CAmCR;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,CAqCR"}

package/types/worklets/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/worklets/transform.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAQvD,wBAAgB,+BAA+B,CAC7C,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,UAAU,UAAQ,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,CAiCpC;AAsCD,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,UAAU,UAAQ,EAClB,OAAO,CAAC,EAAE,wBAAwB,EAClC,gBAAgB,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,GACrE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,CAoP7B"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/worklets/transform.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAQvD,wBAAgB,+BAA+B,CAC7C,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,UAAU,UAAQ,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,CAiCpC;AAsCD,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,UAAU,UAAQ,EAClB,OAAO,CAAC,EAAE,wBAAwB,EAClC,gBAAgB,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,GACrE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,CAuU7B"}

package/types/worklets/types.d.ts

@@ -18,4 +18,10 @@ export interface WorkletCandidate {
     parent?: any;
     isAutoWorklet: boolean;
 }
+export interface WorkletClassCandidate {
+    node: any;
+    name: string;
+    parent?: any;
+    marker: any;
+}
 //# sourceMappingURL=types.d.ts.map

package/types/worklets/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/worklets/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B,sBAAsB,GACtB,qBAAqB,GACrB,gBAAgB,GAChB,eAAe,CAAA;AAEnB,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,GAAG,CAAA;IACT,MAAM,EAAE,GAAG,CAAA;IACX,IAAI,EAAE,oBAAoB,CAAA;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,GAAG,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;CACvB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/worklets/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B,sBAAsB,GACtB,qBAAqB,GACrB,gBAAgB,GAChB,eAAe,CAAA;AAEnB,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,GAAG,CAAA;IACT,MAAM,EAAE,GAAG,CAAA;IACX,IAAI,EAAE,oBAAoB,CAAA;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,GAAG,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,GAAG,CAAA;IACT,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,GAAG,CAAA;IACZ,MAAM,EAAE,GAAG,CAAA;CACZ"}