peachsim 0.1.527

package/src/worklets-babel.ts

@@ -0,0 +1,250 @@
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { TransformOptions } from '@babel/core'
+import type { TransformResult } from 'vite'
+
+const sootsimPluginRequire = createRequire(import.meta.url)
+const sootsimRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const workspaceRoot = path.resolve(sootsimRoot, '..', '..')
+
+// handle files containing upstream reanimated/worklets worklet directives and
+// inline updaters to auto-workletizable hooks. the babel transform lifts those
+// into functions carrying `__closure`, `__workletHash`, and `__initData`.
+export const REANIMATED_AUTOWORKLETIZATION_KEYWORDS = [
+  'worklet',
+  'useAnimatedGestureHandler',
+  'useAnimatedScrollHandler',
+  'useFrameCallback',
+  'useAnimatedStyle',
+  'useAnimatedProps',
+  'createAnimatedPropAdapter',
+  'useDerivedValue',
+  'useAnimatedReaction',
+  'useWorkletCallback',
+  'withTiming',
+  'withSpring',
+  'withDecay',
+  'withRepeat',
+  'runOnUI',
+  'executeOnUIRuntimeSync',
+]
+
+export const REANIMATED_WORKLETIZATION_REGEX = new RegExp(
+  REANIMATED_AUTOWORKLETIZATION_KEYWORDS.join('|'),
+)
+// false-positive packages: they mention the keywords in strings/comments but
+// don't actually use worklets, or transforming them causes circular deps /
+// breaks the build. keep this minimal; the regex above is already
+// content-gated so most of node_modules skips for free.
+const REANIMATED_IGNORED_PATHS_REGEX =
+  /node_modules\/(react|react-dom|react-native|react-native-web)\//
+const SOOTSIM_ENGINE_SRC_PATH = '/packages/sootsim-engine/src/'
+const SOOTSIM_ENGINE_TEST_FIXTURE_PATH = '/packages/sootsim-engine/src/test-fixtures/'
+const REANIMATED_IMPORT_REGEX =
+  /(?:from\s+['"]react-native-reanimated(?:\/[^'"]*)?['"]|require\(\s*['"]react-native-reanimated(?:\/[^'"]*)?['"]\s*\))/
+
+let workletsPluginPath: string | null = null
+let babelCorePromise: Promise<typeof import('@babel/core')> | null = null
+
+export function shouldApplyWorkletsPlugin(id: string, code: string): boolean {
+  if (!/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/.test(id)) return false
+  if (REANIMATED_IGNORED_PATHS_REGEX.test(id)) return false
+  // sootsim engine source has local helpers named like upstream reanimated
+  // hooks. only transform engine files that actually import upstream
+  // react-native-reanimated; otherwise the plugin rewrites callbacks for our
+  // own engine hooks and expects a `this.__closure` binding they never provide.
+  if (
+    id.includes(SOOTSIM_ENGINE_SRC_PATH) &&
+    !id.includes(SOOTSIM_ENGINE_TEST_FIXTURE_PATH) &&
+    !REANIMATED_IMPORT_REGEX.test(code)
+  ) {
+    return false
+  }
+  return REANIMATED_WORKLETIZATION_REGEX.test(code)
+}
+
+function getWorkletsPluginPath(): string {
+  if (!workletsPluginPath) {
+    workletsPluginPath = path.resolve(
+      workspaceRoot,
+      'node_modules',
+      'react-native-worklets',
+      'plugin',
+    )
+  }
+  return workletsPluginPath
+}
+
+function isTypescriptFile(id: string): boolean {
+  return /\.(tsx?|mts|cts)$/.test(id)
+}
+
+// the worklets babel pass is the single most expensive plugin hook in the
+// engine and tenant builds (hundreds of files, several seconds each). the
+// output is a pure function of the source text, the file path, the sourcemap
+// flag, and the babel toolchain, so cache it on disk keyed by all four. a
+// normal dev rebuild changes a handful of files and replays the rest.
+const CACHE_SCHEMA = 'v1'
+const CACHE_ROOT = path.resolve(
+  workspaceRoot,
+  'node_modules',
+  '.cache',
+  'sootsim-worklets',
+)
+
+// null once resolved on a tree we cannot write to (a read-only install), which
+// only costs speed: every caller falls through to the babel run it would have
+// made anyway.
+let cacheDir: string | null | undefined
+
+function getCacheDir(): string | null {
+  if (cacheDir !== undefined) return cacheDir
+  const versions = [
+    '@babel/core',
+    '@babel/preset-typescript',
+    'react-native-worklets',
+  ].map((pkg) => {
+    const manifest = sootsimPluginRequire(`${pkg}/package.json`) as { version?: string }
+    return `${pkg}@${manifest.version ?? '0'}`
+  })
+  const fingerprint = createHash('sha256')
+    .update([CACHE_SCHEMA, ...versions].join('\n'))
+    .digest('hex')
+    .slice(0, 16)
+  const dir = path.join(CACHE_ROOT, fingerprint)
+  try {
+    fs.mkdirSync(dir, { recursive: true })
+    // a toolchain bump starts a new fingerprint, so drop the previous ones
+    // instead of letting every upgrade leave its entries behind forever.
+    for (const entry of fs.readdirSync(CACHE_ROOT)) {
+      if (entry === fingerprint) continue
+      fs.rmSync(path.join(CACHE_ROOT, entry), { recursive: true, force: true })
+    }
+    cacheDir = dir
+  } catch {
+    cacheDir = null
+  }
+  return cacheDir
+}
+
+function getCacheEntryPath(
+  code: string,
+  id: string,
+  sourceMaps: TransformOptions['sourceMaps'],
+): string | null {
+  const dir = getCacheDir()
+  if (!dir) return null
+  // the worklets plugin's `isRelease` reads BABEL_ENV and NODE_ENV and emits a
+  // different worklet for each (release drops the embedded source and map), so
+  // both belong in the key. the same file is built once as a dev tenant bundle
+  // and once as a production engine bundle.
+  const key = createHash('sha256')
+    .update(
+      [
+        id,
+        String(sourceMaps),
+        process.env.BABEL_ENV ?? '',
+        process.env.NODE_ENV ?? '',
+        code,
+      ].join('\0'),
+    )
+    .digest('hex')
+  return path.join(dir, key.slice(0, 2), `${key.slice(2)}.json`)
+}
+
+function readCachedTransform(
+  entryPath: string | null,
+): Pick<TransformResult, 'code' | 'map'> | null {
+  if (!entryPath) return null
+  try {
+    return JSON.parse(fs.readFileSync(entryPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function writeCachedTransform(
+  entryPath: string | null,
+  result: Pick<TransformResult, 'code' | 'map'>,
+): void {
+  if (!entryPath) return
+  try {
+    fs.mkdirSync(path.dirname(entryPath), { recursive: true })
+    // write-then-rename so a concurrent build never reads a half-written entry.
+    const temp = `${entryPath}.${process.pid}.${Math.random().toString(36).slice(2)}`
+    fs.writeFileSync(temp, JSON.stringify(result))
+    fs.renameSync(temp, entryPath)
+  } catch {}
+}
+
+function createWorkletsBabelOptions(
+  id: string,
+  sourceMaps: TransformOptions['sourceMaps'],
+): TransformOptions {
+  const isTSX = id.endsWith('.tsx')
+  const isTS = isTypescriptFile(id)
+  return {
+    filename: id,
+    babelrc: false,
+    configFile: false,
+    sourceMaps,
+    presets: isTS
+      ? [
+          [
+            sootsimPluginRequire.resolve('@babel/preset-typescript'),
+            { isTSX, allExtensions: isTSX, allowDeclareFields: true },
+          ],
+        ]
+      : [],
+    plugins: [
+      [sootsimPluginRequire.resolve('@babel/plugin-syntax-jsx')],
+      [getWorkletsPluginPath(), { processNestedWorklets: true }],
+    ],
+  }
+}
+
+export async function transformWorkletsCode(
+  code: string,
+  id: string,
+  sourceMaps: TransformOptions['sourceMaps'] = true,
+): Promise<Pick<TransformResult, 'code' | 'map'> | null> {
+  const entryPath = getCacheEntryPath(code, id, sourceMaps)
+  const cached = readCachedTransform(entryPath)
+  if (cached) return cached
+  if (!babelCorePromise) {
+    babelCorePromise = import('@babel/core') as Promise<typeof import('@babel/core')>
+  }
+  const { transformAsync } = await babelCorePromise
+  const result = await transformAsync(code, createWorkletsBabelOptions(id, sourceMaps))
+  if (!result?.code) return null
+  const transformed = {
+    code: result.code,
+    map: (result.map ?? null) as TransformResult['map'],
+  }
+  writeCachedTransform(entryPath, transformed)
+  return transformed
+}
+
+export function transformWorkletsCodeSync(
+  code: string,
+  id: string,
+  sourceMaps: TransformOptions['sourceMaps'] = false,
+): Pick<TransformResult, 'code' | 'map'> | null {
+  const entryPath = getCacheEntryPath(code, id, sourceMaps)
+  const cached = readCachedTransform(entryPath)
+  if (cached) return cached
+  const { transformSync } = sootsimPluginRequire(
+    '@babel/core',
+  ) as typeof import('@babel/core')
+  const result = transformSync(code, createWorkletsBabelOptions(id, sourceMaps))
+  if (!result?.code) return null
+  const transformed = {
+    code: result.code,
+    map: (result.map ?? null) as TransformResult['map'],
+  }
+  writeCachedTransform(entryPath, transformed)
+  return transformed
+}