@tamagui/metro-plugin 2.7.7 → 3.0.0-beta.643.1

package/src/transformer.ts

@@ -0,0 +1,210 @@
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, realpathSync, renameSync, writeFileSync } from 'node:fs'
+import { isAbsolute, join, resolve } from 'node:path'
+
+import {
+  compileWithUserBabel,
+  userBabelCacheKey,
+  type MetroBabelTransformArgs,
+  type MetroBabelTransformResult,
+} from './babel'
+import {
+  METRO_COMPILER_CACHE_VERSION,
+  MetroCompilerCache,
+  MetroCompilerCacheError,
+} from './compilerCache'
+import {
+  formatMetroCompilerDiagnostic,
+  metroDiagnostic,
+  type MetroCompilerDiagnostic,
+} from './diagnostics'
+import { isCompilerSourceFile } from './metroResolver'
+import { applyMetroCompilerPlan, type MetroCompilerLoweringResult } from './lowering'
+
+export interface MetroCompilerTransformerOptions {
+  cacheBaseRoot: string
+  originalBabelTransformerPath: string
+  projectRoot: string
+  /**
+   * The integration-owned `TAMAGUI_RUNTIME` literal for this bundle request.
+   * Metro never reads an ambient value: the literal is decided by the build and
+   * inlined here so every guard is a constant.
+   */
+  runtimeLiteral?: 'full' | 'zero'
+}
+
+export interface MetroCompilerTransformMetadata {
+  cacheHit: boolean
+  diagnostics: MetroCompilerDiagnostic[]
+  lowering?: MetroCompilerLoweringResult
+}
+
+export function createMetroCompilerTransformer(config: MetroCompilerTransformerOptions): {
+  transform(args: MetroBabelTransformArgs): Promise<MetroBabelTransformResult>
+  getCacheKey(): string
+} {
+  // Metro hands workers project-relative filenames while the compiler cache is
+  // keyed by absolute realpaths (the frontend realpaths every module). Resolve
+  // to the same form or every plan lookup silently misses and the whole build
+  // ships unlowered.
+  const moduleIdCache = new Map<string, string>()
+  const missWarned = new Set<string>()
+  function cacheModuleId(filename: string): string {
+    let id = moduleIdCache.get(filename)
+    if (!id) {
+      const absolute = isAbsolute(filename)
+        ? filename
+        : resolve(config.projectRoot, filename)
+      try {
+        id = realpathSync(absolute)
+      } catch {
+        id = absolute
+      }
+      moduleIdCache.set(filename, id)
+    }
+    return id
+  }
+  // Metro also transforms modules the frontend can never plan: bundler-injected
+  // polyfills, virtual modules, and node_modules (external by design). A miss
+  // is only a lowering defect for a file the frontend's project graph would
+  // have crawled.
+  function planEligible(moduleId: string): boolean {
+    return (
+      isCompilerSourceFile(moduleId) &&
+      !moduleId.includes(`${join('node_modules')}`) &&
+      existsSync(moduleId)
+    )
+  }
+  // Replaces only the exact member expression `process.env.TAMAGUI_RUNTIME`.
+  // Metro has no define mechanism, so this is the transform-level equivalent.
+  const runtimeLiteral = config.runtimeLiteral ?? 'full'
+  const inlineRuntimeLiteral = ({ types }: { types: any }) => ({
+    visitor: {
+      MemberExpression(nodePath: any) {
+        const node = nodePath.node
+        if (
+          node.computed ||
+          !types.isIdentifier(node.property, { name: 'TAMAGUI_RUNTIME' }) ||
+          !types.isMemberExpression(node.object) ||
+          node.object.computed ||
+          !types.isIdentifier(node.object.object, { name: 'process' }) ||
+          !types.isIdentifier(node.object.property, { name: 'env' })
+        ) {
+          return
+        }
+        nodePath.replaceWith(types.stringLiteral(runtimeLiteral))
+      },
+    },
+  })
+
+  return {
+    async transform(argsIn) {
+      const args = {
+        ...argsIn,
+        plugins: [...(argsIn.plugins ?? []), inlineRuntimeLiteral],
+      }
+      const platform =
+        typeof args.options.platform === 'string' ? args.options.platform : 'default'
+      const cache = new MetroCompilerCache(join(config.cacheBaseRoot, platform))
+      let tamagui: MetroCompilerTransformMetadata = {
+        cacheHit: false,
+        diagnostics: [],
+      }
+      const moduleId = cacheModuleId(args.filename)
+      try {
+        // a manifest exists exactly when the frontend planned this build, so a
+        // lookup miss on a plannable file is a lowering defect (unlowered
+        // output), never routine — surface it instead of silently shipping
+        // runtime-path modules
+        const entry = await cache.read(moduleId, args.src, (reason, detail) => {
+          if (missWarned.has(moduleId) || !planEligible(moduleId)) return
+          missWarned.add(moduleId)
+          const diagnostic = metroDiagnostic(
+            'metro/plan-miss',
+            `Lowering plan lookup missed for ${moduleId} (${reason}${detail ? `: ${detail}` : ''}); module ships unlowered`,
+            { moduleId }
+          )
+          tamagui.diagnostics.push(diagnostic)
+          console.warn(formatMetroCompilerDiagnostic(diagnostic, config.projectRoot))
+        })
+        if (entry) {
+          try {
+            const lowered = await applyMetroCompilerPlan(
+              { ...args, filename: moduleId },
+              entry.plan,
+              config.originalBabelTransformerPath
+            )
+            return {
+              ...lowered.compiled.result,
+              metadata: {
+                ...lowered.compiled.result.metadata,
+                tamagui: {
+                  cacheHit: true,
+                  diagnostics: entry.diagnostics,
+                  lowering: lowered.lowering,
+                },
+              },
+            }
+          } catch (error) {
+            const diagnostic = metroDiagnostic(
+              'metro/cache-corrupt',
+              `Cached lowering plan for ${args.filename} could not be applied: ${error instanceof Error ? error.message : String(error)}`,
+              { moduleId }
+            )
+            tamagui = {
+              cacheHit: true,
+              diagnostics: [...entry.diagnostics, diagnostic],
+            }
+            console.warn(formatMetroCompilerDiagnostic(diagnostic, config.projectRoot))
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof MetroCompilerCacheError)) throw error
+        tamagui.diagnostics.push(error.diagnostic)
+        console.warn(formatMetroCompilerDiagnostic(error.diagnostic, config.projectRoot))
+      }
+      const compiled = await compileWithUserBabel(
+        config.originalBabelTransformerPath,
+        args
+      )
+      return {
+        ...compiled.result,
+        metadata: {
+          ...compiled.result.metadata,
+          tamagui,
+        },
+      }
+    },
+    getCacheKey() {
+      return createHash('sha256')
+        .update(`tamagui-metro-compiler-v${METRO_COMPILER_CACHE_VERSION}`)
+        .update('\0')
+        .update(runtimeLiteral)
+        .update('\0')
+        .update(userBabelCacheKey(config.originalBabelTransformerPath))
+        .digest('hex')
+    },
+  }
+}
+
+export function writeMetroCompilerTransformerBridge(
+  transformerFactoryPath: string,
+  config: MetroCompilerTransformerOptions
+): string {
+  const serializedConfig = JSON.stringify(config)
+  const bridgeHash = createHash('sha256')
+    .update(transformerFactoryPath)
+    .update('\0')
+    .update(serializedConfig)
+    .digest('hex')
+  const directory = join(config.cacheBaseRoot, 'bridge')
+  const bridgePath = join(directory, `${bridgeHash}.cjs`)
+  const temporaryPath = `${bridgePath}.${process.pid}.tmp`
+  const source = `'use strict'\nmodule.exports = require(${JSON.stringify(
+    transformerFactoryPath
+  )}).createMetroCompilerTransformer(${serializedConfig})\n`
+  mkdirSync(directory, { recursive: true })
+  writeFileSync(temporaryPath, source, 'utf8')
+  renameSync(temporaryPath, bridgePath)
+  return bridgePath
+}

package/src/zeroRuntime.ts

@@ -0,0 +1,212 @@
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+
+import Static from '@tamagui/static'
+import type {
+  IslandThemeBridge,
+  TamaguiOptions,
+  ZeroCSSArtifact,
+  ZeroRuntimeResolved,
+  ZeroViolationSite,
+} from '@tamagui/static'
+
+/**
+ * Metro's half of the zero-runtime mode.
+ *
+ * Metro fixes a module's dependencies at resolution time and does no
+ * export-level shaking, so nothing after the transform can remove an import.
+ * The frontend already lowers every module up front and publishes plans that
+ * workers apply before Babel runs, which is the one place early enough: zero
+ * reference erasure rides those same plans.
+ *
+ * An island is a second Metro bundle request rather than a child compilation,
+ * because Metro has no sub-compilation concept. The two requests are separate
+ * processes, so the CSS coordinator hands island fragments over on disk.
+ */
+
+export const ZERO_CSS_FILENAME = 'tamagui-zero.css'
+export const ZERO_ISLAND_DIRNAME = 'tamagui-islands'
+
+export interface MetroZeroController {
+  resolved: ZeroRuntimeResolved
+  artifact: ZeroCSSArtifact
+  cssHref: string
+  root: string
+  /** Directory the artifact and island bundle are published from. */
+  publicDir: string
+  /** Island id when this Metro invocation is building an island, else null. */
+  islandBuild: string | null
+  bridges: Map<string, IslandThemeBridge[]>
+  violations: ZeroViolationSite[]
+  /** Modules the zero transform ran on, for the erased-export gate. */
+  transformed: Set<string>
+  /** Erased exported declarator names, by declaring module. */
+  erasedExports: Map<string, string[]>
+  loaderIds: Map<string, string>
+  islandModuleIds: Map<string, string>
+  /** False in `report` mode, where the analysis runs and nothing else changes. */
+  isEnforcing: boolean
+  /** The evaluated config's CSS, set once the frontend has loaded the project. */
+  configCSS: string
+  /**
+   * True when this build restored the artifact from the plan cache's CSS
+   * sidecar instead of rescanning. Recorded in the receipt so a warm rebuild
+   * that silently stopped reusing plans, or one that reused them without
+   * restoring the artifact, is visible rather than inferred from timing.
+   */
+  plansRestoredFromCache: boolean
+}
+
+const normalizePath = (value: string) => value.replace(/\\/g, '/')
+
+export const zeroModuleKey = (value: string): string =>
+  normalizePath(value).replace(/\.(?:js|jsx|ts|tsx|mjs|cjs)$/, '')
+
+/** Where an island build leaves its CSS fragment for the zero build to collect. */
+export function islandFragmentPath(outDir: string, islandId: string): string {
+  return path.join(outDir, ZERO_ISLAND_DIRNAME, `${islandId}.css`)
+}
+
+export function islandBundleHashPath(outDir: string, islandId: string): string {
+  return path.join(outDir, ZERO_ISLAND_DIRNAME, `${islandId}.hash`)
+}
+
+export function createMetroZeroController(
+  options: TamaguiOptions,
+  root: string,
+  islandBuild: string | null,
+  publicDirName: string
+): MetroZeroController | null {
+  const resolved = Static.resolveZeroRuntimeSync(options, root)
+  if (resolved.mode === 'off') return null
+  Static.assertZeroIntegrationSupport('metro-web', resolved)
+
+  const cssHref = `/${ZERO_CSS_FILENAME}`
+  const artifact = new Static.ZeroCSSArtifact(resolved.cssPath)
+  artifact.expectIslands(resolved.islands.map((island) => island.id))
+
+  const configPath = path.isAbsolute(options.config || '')
+    ? options.config!
+    : path.resolve(root, options.config || 'tamagui.config.ts')
+
+  for (const island of resolved.islands) {
+    Static.writeIslandModules({
+      island,
+      integration: 'metro-web',
+      configPath,
+      scriptUrl: `/${ZERO_ISLAND_DIRNAME}/${island.id}.js`,
+      cssHref,
+    })
+  }
+
+  return {
+    resolved,
+    artifact,
+    cssHref,
+    root,
+    publicDir: path.join(root, publicDirName),
+    islandBuild,
+    bridges: new Map(),
+    violations: [],
+    transformed: new Set(),
+    erasedExports: new Map(),
+    isEnforcing: resolved.mode === 'enforce',
+    loaderIds: new Map(
+      resolved.islands.map((island) => [zeroModuleKey(island.loader), island.id])
+    ),
+    islandModuleIds: new Map(
+      resolved.islands.map((island) => [zeroModuleKey(island.module), island.id])
+    ),
+    configCSS: '',
+    plansRestoredFromCache: false,
+  }
+}
+
+/**
+ * Generated shim modules for the island bundle's React handoff.
+ *
+ * Metro has no externals option, so the island build redirects `react`,
+ * `react-dom`, and `react/jsx-runtime` through these, which read the handoff
+ * the generated loader publishes. One React instance serves both graphs.
+ */
+export function writeIslandRuntimeShims(outDir: string): Record<string, string> {
+  const directory = path.join(outDir, 'runtime-shim')
+  mkdirSync(directory, { recursive: true })
+  const shims: Record<string, string> = {}
+  for (const [specifier, segments] of Object.entries(
+    Static.ISLAND_EXTERNAL_GLOBAL_PATHS
+  )) {
+    const file = path.join(directory, `${specifier.replace(/[^a-zA-Z0-9]+/g, '_')}.js`)
+    const source = `// generated by @tamagui/metro-plugin zero-runtime. do not edit.\nmodule.exports = globalThis.${segments.join(
+      '.'
+    )}\n`
+    if (!existsSync(file) || readFileSync(file, 'utf8') !== source) {
+      writeFileSync(file, source)
+    }
+    shims[specifier] = file
+  }
+  return shims
+}
+
+export interface MetroZeroFinalizeInput {
+  controller: MetroZeroController
+  /** The serialized bundle, hashed into the island's output receipt. */
+  bundleCode: string
+}
+
+/**
+ * Writes the one CSS artifact for a zero build, or this island's fragment for
+ * an island build. `TAMAGUI_DID_OUTPUT_CSS` is derived only when every declared
+ * island fragment is present.
+ */
+export function finalizeMetroZero(input: MetroZeroFinalizeInput): {
+  cssPath: string
+  hash: string
+  islandOutputHashes: Record<string, string>
+} {
+  const { controller } = input
+  const outDir = controller.resolved.outDir
+
+  if (controller.islandBuild) {
+    const fragment = [...controller.artifact.islandCSS(controller.islandBuild)].join('')
+    const file = islandFragmentPath(outDir, controller.islandBuild)
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(file, fragment)
+    writeFileSync(
+      islandBundleHashPath(outDir, controller.islandBuild),
+      createHash('sha256').update(input.bundleCode).digest('hex').slice(0, 16)
+    )
+    return { cssPath: file, hash: '', islandOutputHashes: {} }
+  }
+
+  controller.artifact.setConfigCSS(controller.configCSS)
+  const islandOutputHashes: Record<string, string> = {}
+  for (const island of controller.resolved.islands) {
+    const fragment = islandFragmentPath(outDir, island.id)
+    if (!existsSync(fragment)) {
+      throw new Error(
+        `[tamagui zero-runtime] island "${island.id}" has not been built. Build every declared island bundle before the zero entry so the one CSS artifact can be finalized.`
+      )
+    }
+    controller.artifact.setIslandModuleCSS(
+      island.id,
+      island.module,
+      readFileSync(fragment, 'utf8')
+    )
+    const hashFile = islandBundleHashPath(outDir, island.id)
+    islandOutputHashes[island.id] = existsSync(hashFile)
+      ? readFileSync(hashFile, 'utf8')
+      : ''
+  }
+
+  const written = controller.artifact.write()
+  if (!written.complete) {
+    throw new Error(
+      `[tamagui zero-runtime] cannot derive TAMAGUI_DID_OUTPUT_CSS: the generated CSS artifact is missing ${written.missing.join(
+        ', '
+      )}`
+    )
+  }
+  return { cssPath: written.path, hash: written.hash, islandOutputHashes }
+}

package/src/zeroSerializer.ts

@@ -0,0 +1,175 @@
+import { mkdirSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { gzipSync } from 'node:zlib'
+
+import Static from '@tamagui/static'
+import type { ZeroGraphReceipt } from '@tamagui/static'
+
+import {
+  finalizeMetroZero,
+  writeIslandRuntimeShims,
+  ZERO_CSS_FILENAME,
+  ZERO_ISLAND_DIRNAME,
+  type MetroZeroController,
+} from './zeroRuntime'
+
+/**
+ * Metro's serializer-time gate and the resolver redirects the island bundle
+ * needs.
+ *
+ * The serializer is the first point where Metro's whole module graph exists,
+ * so it is where the forbidden-module check runs. It is not where erasure
+ * happens: Metro fixes dependencies at resolution, so by serializer time a
+ * surviving import is already a graph member. That is the point of checking
+ * here rather than fixing here.
+ */
+
+const requireFromPlugin = createRequire(
+  typeof __filename === 'string' ? __filename : import.meta.url
+)
+
+// version-pinned, not a feature-detection chain: this is the serializer the
+// repository's Metro ships, and it is used only when the app supplied none
+const baseJSBundle = requireFromPlugin(
+  'metro/private/DeltaBundler/Serializers/baseJSBundle'
+).default as (entryPoint: any, preModules: any, graph: any, options: any) => any
+const bundleToString = requireFromPlugin('metro/private/lib/bundleToString').default as (
+  bundle: any
+) => { code: string; map: string }
+
+type MetroConfigInput = Record<string, any>
+
+export function applyMetroZeroRuntime(
+  metroConfig: MetroConfigInput,
+  zero: MetroZeroController
+): void {
+  if (zero.islandBuild) {
+    // Metro has no externals option, so React is redirected through generated
+    // shim modules that read the handoff the island loader publishes
+    const shims = writeIslandRuntimeShims(zero.resolved.outDir)
+    const userResolveRequest = metroConfig.resolver?.resolveRequest
+    metroConfig.resolver = {
+      ...metroConfig.resolver,
+      resolveRequest(context: any, moduleName: string, platform: string | null) {
+        const shim = shims[moduleName]
+        if (shim) return { type: 'sourceFile', filePath: shim }
+        return userResolveRequest
+          ? userResolveRequest(context, moduleName, platform)
+          : context.resolveRequest(context, moduleName, platform)
+      },
+    }
+  }
+
+  const userSerializer = metroConfig.serializer?.customSerializer
+  metroConfig.serializer = {
+    ...metroConfig.serializer,
+    async customSerializer(entryPoint: any, preModules: any, graph: any, opts: any) {
+      const receipt = checkGraph(zero, entryPoint, graph)
+      const output = userSerializer
+        ? await userSerializer(entryPoint, preModules, graph, opts)
+        : bundleToString(baseJSBundle(entryPoint, preModules, graph, opts)).code
+
+      const finalized = finalizeMetroZero({
+        controller: zero,
+        bundleCode: typeof output === 'string' ? output : '',
+      })
+
+      if (!zero.islandBuild) {
+        mkdirSync(zero.publicDir, { recursive: true })
+        const css = zero.artifact.css()
+        const published = path.join(zero.publicDir, ZERO_CSS_FILENAME)
+        writeFileSync(published, css)
+        // the served copy is what the page loads, so it is the one the claim
+        // depends on: read it back rather than trusting the write
+        const publishFailure = Static.checkGlobalCSSArtifact({
+          cssPath: published,
+          expectedCSS: css,
+          loadedModuleIds: [published],
+          importHint: '',
+        })
+        if (publishFailure) throw new Error(publishFailure.message)
+        receipt.cssArtifact = { path: zero.cssHref, hash: finalized.hash }
+        receipt.gzip = {
+          [ZERO_CSS_FILENAME]: gzipSync(Buffer.from(css), { level: 9 }).length,
+          bundle: gzipSync(Buffer.from(typeof output === 'string' ? output : ''), {
+            level: 9,
+          }).length,
+        }
+        const bridgeManifest = Static.canonicalizeBridgeManifest(
+          Object.fromEntries(
+            [...zero.bridges.entries()].sort(([left], [right]) => (left < right ? -1 : 1))
+          )
+        )
+        const identityInputs = {
+          runtimeLiteral: 'zero' as const,
+          target: 'web' as const,
+          configGeneration: Static.hashBridgeManifest(zero.configCSS),
+          cssHash: finalized.hash,
+          compilerVersion: Static.ZERO_COMPILER_VERSION,
+          islandEntries: zero.resolved.islands.map((island) => island.module),
+          bridgeManifestHash: Static.hashBridgeManifest(bridgeManifest),
+          islandOutputHashes: finalized.islandOutputHashes,
+        }
+        receipt.identity = Static.hashZeroIdentity(identityInputs)
+        receipt.plansRestoredFromCache = zero.plansRestoredFromCache
+        Static.writeZeroGraphReceipt(zero.resolved.outDir, 'metro-zero', receipt)
+        writeFileSync(
+          path.join(zero.resolved.outDir, 'metro-zero.bridges.json'),
+          `${JSON.stringify(
+            { identity: receipt.identity, identityInputs, bridges: bridgeManifest },
+            null,
+            2
+          )}\n`
+        )
+        if (receipt.forbidden.length) {
+          throw new Error(Static.formatZeroGraphFailure(receipt))
+        }
+        console.info(
+          `  ➡ [tamagui zero-runtime] ${receipt.moduleCount} modules, 0 forbidden, css ${receipt.gzip[ZERO_CSS_FILENAME]} gzip, islands: ${
+            zero.resolved.islands.map((island) => island.id).join(', ') || 'none'
+          }`
+        )
+      }
+
+      return output
+    },
+  }
+}
+
+function checkGraph(
+  zero: MetroZeroController,
+  entryPoint: string,
+  graph: { dependencies: Map<string, any> }
+): ZeroGraphReceipt {
+  const modules: { id: string; importers: string[] }[] = []
+  const importerEdges = new Map<string, string[]>()
+  for (const [id, module] of graph.dependencies) {
+    const importers = [...(module.inverseDependencies ?? [])] as string[]
+    importerEdges.set(id, importers)
+    modules.push({ id, importers })
+  }
+  const escape = Static.erasedExportEscape({
+    integration: 'metro-web',
+    transformed: zero.transformed,
+    erasedExports: zero.erasedExports,
+    importersOf: importerEdges,
+  })
+  if (escape) throw new Error(escape)
+  const checked = Static.checkZeroGraph({
+    entries: [entryPoint],
+    modules,
+    importerEdges,
+    root: zero.resolved.root,
+  })
+  return {
+    integration: 'metro-web',
+    graph: zero.islandBuild ? 'island' : 'zero',
+    entries: [entryPoint],
+    moduleCount: modules.length,
+    tamaguiModules: checked.tamaguiModules,
+    forbidden: checked.forbidden,
+    cssArtifact: null,
+    identity: '',
+  }
+}

package/types/babel.d.ts

@@ -0,0 +1,28 @@
+export interface MetroBabelTransformArgs {
+	filename: string;
+	src: string;
+	options: Record<string, any>;
+	plugins: unknown[];
+}
+export interface MetroBabelTransformResult {
+	ast: Record<string, any>;
+	metadata?: Record<string, any>;
+	functionMap?: unknown;
+	[key: string]: unknown;
+}
+export interface CompiledMetroModule {
+	code: string;
+	map: Record<string, any>;
+	result: MetroBabelTransformResult;
+}
+type BabelTransformer = {
+	transform(args: MetroBabelTransformArgs): MetroBabelTransformResult | Promise<MetroBabelTransformResult>;
+	getCacheKey?(): string;
+};
+export declare function loadMetroBabelTransformer(path: string): BabelTransformer;
+export declare function compileWithUserBabel(transformerPath: string, args: MetroBabelTransformArgs): Promise<CompiledMetroModule>;
+export declare function userBabelCacheKey(transformerPath: string): string;
+export declare function transformerDirectory(transformerPath: string): string;
+export {};
+
+//# sourceMappingURL=babel.d.ts.map

package/types/babel.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAIA,iBAAiB,wBAAwB;CACvC;CACA;CACA,SAAS;CACT;;AAGF,iBAAiB,0BAA0B;CACzC,KAAK;CACL,WAAW;CACX;;;AAIF,iBAAiB,oBAAoB;CACnC;CACA,KAAK;CACL,QAAQ;;KAGL,mBAAmB;CACtB,UACE,MAAM,0BACL,4BAA4B,QAAQ;CACvC;;AAWF,OAAO,iBAAS,0BAA0B,eAAe;AAIzD,OAAO,iBAAe,qBACpB,yBACA,MAAM,0BACL,QAAQ;AA6BX,OAAO,iBAAS,kBAAkB;AASlC,OAAO,iBAAS,qBAAqB",
+  "names": [],
+  "sources": [
+    "src/babel.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { createHash } from 'node:crypto'\nimport { createRequire } from 'node:module'\nimport { dirname } from 'node:path'\n\nexport interface MetroBabelTransformArgs {\n  filename: string\n  src: string\n  options: Record<string, any>\n  plugins: unknown[]\n}\n\nexport interface MetroBabelTransformResult {\n  ast: Record<string, any>\n  metadata?: Record<string, any>\n  functionMap?: unknown\n  [key: string]: unknown\n}\n\nexport interface CompiledMetroModule {\n  code: string\n  map: Record<string, any>\n  result: MetroBabelTransformResult\n}\n\ntype BabelTransformer = {\n  transform(\n    args: MetroBabelTransformArgs\n  ): MetroBabelTransformResult | Promise<MetroBabelTransformResult>\n  getCacheKey?(): string\n}\n\nfunction asTransformer(module: any, path: string): BabelTransformer {\n  const transformer = module?.default?.transform ? module.default : module\n  if (!transformer || typeof transformer.transform !== 'function') {\n    throw new Error(`Metro Babel transformer ${path} has no transform function`)\n  }\n  return transformer\n}\n\nexport function loadMetroBabelTransformer(path: string): BabelTransformer {\n  return asTransformer(createRequire(path)(path), path)\n}\n\nexport async function compileWithUserBabel(\n  transformerPath: string,\n  args: MetroBabelTransformArgs\n): Promise<CompiledMetroModule> {\n  const transformer = loadMetroBabelTransformer(transformerPath)\n  const result = await transformer.transform(args)\n  if (!result?.ast) {\n    throw new Error(`Metro Babel transformer ${transformerPath} returned no AST`)\n  }\n  const requireFromTransformer = createRequire(transformerPath)\n  const generatorModule = requireFromTransformer('@babel/generator')\n  const generate = generatorModule.default ?? generatorModule\n  const generated = generate(\n    result.ast,\n    {\n      comments: true,\n      compact: false,\n      retainLines: true,\n      sourceFileName: args.filename,\n      sourceMaps: true,\n    },\n    args.src\n  )\n  if (!generated || typeof generated.code !== 'string') {\n    throw new Error(`Babel generator for ${transformerPath} returned no code`)\n  }\n  if (!generated.map) {\n    throw new Error(`Babel generator for ${transformerPath} returned no source map`)\n  }\n  return { code: generated.code, map: generated.map, result }\n}\n\nexport function userBabelCacheKey(transformerPath: string): string {\n  const transformer = loadMetroBabelTransformer(transformerPath)\n  return createHash('sha256')\n    .update(transformerPath)\n    .update('\\0')\n    .update(transformer.getCacheKey?.() ?? '')\n    .digest('hex')\n}\n\nexport function transformerDirectory(transformerPath: string): string {\n  return dirname(transformerPath)\n}\n"
+  ]
+}