@vxrn/compiler 1.26.1 → 1.27.1-1789414853455

package/dist/cjs/cache.cjs

@@ -48,30 +48,44 @@ function getCacheDir() {
   }
   return cacheDir;
 }
-function getConfigFingerprint() {
+function getConfigFingerprint(userBabelConfigPath) {
   return (0, import_node_crypto.createHash)("sha1").update(JSON.stringify({
     compiler: import_configure.configuration.enableCompiler,
     reanimated: import_configure.configuration.enableReanimated,
     nativeWorklets: (0, import_configure.isNativeWorkletsEnabled)(),
     nativewind: import_configure.configuration.enableNativewind,
     nativeCSS: import_configure.configuration.enableNativeCSS,
+    // transform output depends on the user babel config when one applies,
+    // so its identity joins the fingerprint. adding, removing, or editing
+    // babel.config.* must miss entries written without that change.
+    babelConfig: getBabelConfigIdentity(userBabelConfigPath),
     // bump when the transform engine changes, so entries written by a
     // previous engine aren't served for the same source
     engine: "oxc-worklets-hermes-async"
   })).digest("hex").slice(0, 8);
 }
-function getCacheKey(filePath, environment) {
-  const hash = (0, import_node_crypto.createHash)("sha1").update(`${environment}:${filePath}:${getConfigFingerprint()}`).digest("hex");
+function getBabelConfigIdentity(configPath) {
+  if (!configPath) return null;
+  try {
+    const mtime = (0, import_node_fs.statSync)(configPath).mtimeMs;
+    const hash = (0, import_node_crypto.createHash)("sha1").update((0, import_node_fs.readFileSync)(configPath)).digest("hex").slice(0, 16);
+    return `${configPath}:${mtime}:${hash}`;
+  } catch {
+    return configPath;
+  }
+}
+function getCacheKey(filePath, environment, userBabelConfigPath) {
+  const hash = (0, import_node_crypto.createHash)("sha1").update(`${environment}:${filePath}:${getConfigFingerprint(userBabelConfigPath)}`).digest("hex");
   return hash;
 }
 function getContentHash(code) {
   return (0, import_node_crypto.createHash)("sha1").update(code).digest("hex").slice(0, 16);
 }
-function getCachedTransform(filePath, code, environment) {
+function getCachedTransform(filePath, code, environment, userBabelConfigPath) {
   try {
     const cleanPath = filePath.startsWith("\0") ? filePath.slice(1) : filePath;
     const cacheDir = getCacheDir();
-    const cacheKey = getCacheKey(cleanPath, environment);
+    const cacheKey = getCacheKey(cleanPath, environment, userBabelConfigPath);
     const cachePath = (0, import_node_path.join)(cacheDir, `${cacheKey}.json`);
     if (!(0, import_node_fs.existsSync)(cachePath)) {
       stats.misses++;
@@ -98,11 +112,11 @@ function getCachedTransform(filePath, code, environment) {
     return null;
   }
 }
-function setCachedTransform(filePath, code, result, environment) {
+function setCachedTransform(filePath, code, result, environment, userBabelConfigPath) {
   try {
     const cleanPath = filePath.startsWith("\0") ? filePath.slice(1) : filePath;
     const cacheDir = getCacheDir();
-    const cacheKey = getCacheKey(cleanPath, environment);
+    const cacheKey = getCacheKey(cleanPath, environment, userBabelConfigPath);
     const cachePath = (0, import_node_path.join)(cacheDir, `${cacheKey}.json`);
     const mtime = (0, import_node_fs.statSync)(cleanPath).mtimeMs;
     const hash = getContentHash(code);

package/dist/cjs/index.cjs

@@ -155,7 +155,8 @@ async function performBabelTransform({
     });
     if (babelOptions) {
       const hasCompilerPlugin = babelOptions.plugins?.some(x => Array.isArray(x) && x[0] === "babel-plugin-react-compiler");
-      const cached = (0, import_cache.getCachedTransform)(id, code, environment);
+      const userBabelConfigPath = typeof babelOptions.configFile === "string" ? babelOptions.configFile : null;
+      const cached = (0, import_cache.getCachedTransform)(id, code, environment, userBabelConfigPath);
       if (cached) {
         perfStats.babel.byEnvironment[environment].transforms++;
         if (hasCompilerPlugin && (cached.code.includes("react/compiler-runtime") || cached.code.includes("react-compiler-runtime"))) {
@@ -181,14 +182,18 @@ async function performBabelTransform({
       let compilerOut = null;
       const compilerPluginIndex = babelOptions.plugins?.findIndex(x => Array.isArray(x) && x[0] === "babel-plugin-react-compiler") ?? -1;
       if (compilerPluginIndex !== -1) {
-        if (useWorklets) {
-          workletPreparation = (0, import_transformWorklets.prepareWorkletsForReactCompiler)(id, curCode, (0, import_transformSWC.shouldSourceMap)());
-          if (workletPreparation) curCode = workletPreparation.code;
+        const compilerPluginConfig = babelOptions.plugins[compilerPluginIndex];
+        const compilerPluginOptions = compilerPluginConfig[1] || {};
+        const useBabelCompiler = compilerPluginOptions.compiler === "babel" || process.env.ONE_REACT_COMPILER === "babel" || process.env.VXRN_REACT_COMPILER === "babel";
+        if (!useBabelCompiler) {
+          if (useWorklets) {
+            workletPreparation = (0, import_transformWorklets.prepareWorkletsForReactCompiler)(id, curCode, (0, import_transformSWC.shouldSourceMap)());
+            if (workletPreparation) curCode = workletPreparation.code;
+          }
+          compilerOut = await (0, import_transformBabel.transformOxcReactCompiler)(id, curCode, compilerPluginOptions, (0, import_transformSWC.shouldSourceMap)());
+          if (compilerOut) curCode = compilerOut.code;
+          babelOptions.plugins.splice(compilerPluginIndex, 1);
         }
-        const compilerTarget = babelOptions.plugins[compilerPluginIndex][1]?.target ?? "19";
-        compilerOut = await (0, import_transformBabel.transformOxcReactCompiler)(id, curCode, compilerTarget, (0, import_transformSWC.shouldSourceMap)());
-        if (compilerOut) curCode = compilerOut.code;
-        babelOptions.plugins.splice(compilerPluginIndex, 1);
       }
       let workletsOut = null;
       if (useWorklets) {
@@ -201,7 +206,7 @@ async function performBabelTransform({
       }
       const startTime = Date.now();
       let babelOut = null;
-      if (babelOptions.plugins?.length === 0) {
+      if (babelOptions.plugins?.length === 0 && !babelOptions.configFile && !babelOptions.babelrc) {
         let finalMap = void 0;
         if ((0, import_transformSWC.shouldSourceMap)()) {
           const intermediateMaps = [workletPreparation?.map, compilerOut?.map, workletsOut?.map].filter(Boolean);
@@ -247,7 +252,7 @@ async function performBabelTransform({
           code: outCode,
           map: babelOut.map
         };
-        (0, import_cache.setCachedTransform)(id, code, result, environment);
+        (0, import_cache.setCachedTransform)(id, code, result, environment, userBabelConfigPath);
         return result;
       }
     }

package/dist/cjs/transformBabel.cjs

@@ -33,33 +33,71 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var transformBabel_exports = {};
 __export(transformBabel_exports, {
+  findUserBabelConfig: () => findUserBabelConfig,
   getBabelOptions: () => getBabelOptions,
+  stripFlowTypes: () => stripFlowTypes,
   transformBabel: () => transformBabel,
   transformOxcReactCompiler: () => transformOxcReactCompiler
 });
 module.exports = __toCommonJS(transformBabel_exports);
+var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 var import_utils = require("@vxrn/utils");
 var import_vite = require("vite");
 var import_configure = require("./configure.cjs");
 var import_constants = require("./constants.cjs");
+const USER_BABEL_CONFIG_FILES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", ".babelrc", ".babelrc.js", ".babelrc.json"];
+const ONE_GENERATED_MARKER = "@one-generated";
+function findUserBabelConfig(projectRoot) {
+  if (!projectRoot) return null;
+  for (const name of USER_BABEL_CONFIG_FILES) {
+    const fullPath = (0, import_node_path.join)(projectRoot, name);
+    if ((0, import_node_fs.existsSync)(fullPath)) {
+      try {
+        const content = (0, import_node_fs.readFileSync)(fullPath, "utf8");
+        if (content.includes(ONE_GENERATED_MARKER)) {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      return fullPath;
+    }
+  }
+  return null;
+}
 function getBabelOptions(props) {
   props = {
     ...props,
     id: (0, import_vite.normalizePath)(props.id.split("?")[0])
   };
+  const isProjectFile = !props.id.includes("node_modules");
+  const userBabelConfig = isProjectFile && props.projectRoot ? findUserBabelConfig(props.projectRoot) : null;
   if (props.userSetting === "babel") {
-    return getOptions(props, true);
+    return getOptions(props, true, userBabelConfig);
   }
   if (typeof props.userSetting === "undefined" || typeof props.userSetting === "object" && props.userSetting.transform === "babel") {
     if (props.userSetting?.excludeDefaultPlugins) {
-      return props.userSetting;
+      return {
+        ...props.userSetting,
+        ...(userBabelConfig ? {
+          configFile: userBabelConfig,
+          babelrc: true
+        } : {})
+      };
     }
-    return getOptions(props);
+    return getOptions(props, false, userBabelConfig);
+  }
+  const userSetting = props.userSetting;
+  if (userSetting === "swc" || userSetting === "oxc" || userSetting === false || typeof userSetting === "object" && userSetting !== null && (userSetting.transform === "swc" || userSetting.transform === "oxc")) {
+    return null;
+  }
+  if (userBabelConfig) {
+    return getOptions(props, false, userBabelConfig);
   }
   return null;
 }
-const getOptions = (props, force = false) => {
+const getOptions = (props, force = false, userBabelConfig = null) => {
   let plugins = [];
   if (force || shouldBabelGenerators(props)) {
     plugins = getBasePlugins(props);
@@ -85,22 +123,35 @@ const getOptions = (props, force = false) => {
     (0, import_constants.debug)?.(`Using babel react compiler on file`);
     plugins.push(getBabelReactCompilerPlugin(props));
   }
-  if (plugins.length) {
+  if (plugins.length || userBabelConfig) {
     return {
-      plugins
+      plugins,
+      ...(userBabelConfig ? {
+        configFile: userBabelConfig,
+        babelrc: true
+      } : {})
     };
   }
   return null;
 };
-async function transformOxcReactCompiler(id, code, target, sourceMap = false) {
+async function transformOxcReactCompiler(id, code, optionsOrTarget = "19", sourceMap = false) {
   const {
     transform
   } = await import("oxc-transform-react");
+  const compilerOptions = typeof optionsOrTarget === "string" ? {
+    target: optionsOrTarget
+  } : optionsOrTarget || {};
+  const target = compilerOptions.target ?? "19";
   const result = await transform(id, code, {
     jsx: "preserve",
     sourcemap: sourceMap,
     reactCompiler: {
-      target
+      target,
+      ...compilerOptions,
+      environment: {
+        enableCustomTypeDefinitionForReanimated: true,
+        ...compilerOptions.environment
+      }
     }
   });
   if (result.fatal) {
@@ -126,8 +177,8 @@ async function transformBabel(id, code, options) {
   const babelOptions = {
     filename: id,
     compact: false,
-    babelrc: false,
-    configFile: false,
+    babelrc: options.babelrc ?? false,
+    configFile: options.configFile ?? false,
     sourceMaps: false,
     minified: false,
     ...options,
@@ -146,7 +197,7 @@ async function transformBabel(id, code, options) {
     plugins: [...(isTS ? [] : [[hermesParserPlugin, {
       parseLangTypes: "flow",
       reactRuntimeTarget: "19"
-    }]]), ...(options.plugins || []), ...(isTS ? [] : ["@babel/plugin-transform-flow-strip-types"])]
+    }], "babel-plugin-transform-flow-enums"]), ...(options.plugins || []), ...(isTS ? [] : ["@babel/plugin-transform-flow-strip-types"])]
   };
   return await new Promise((res, rej) => {
     babelCore.transform(code, babelOptions, (err, result) => {
@@ -157,6 +208,15 @@ async function transformBabel(id, code, options) {
     });
   });
 }
+async function stripFlowTypes(id, code, sourceMaps = true) {
+  const result = await transformBabel(id, code, {
+    sourceMaps
+  });
+  return {
+    code: result.code,
+    map: result.map
+  };
+}
 const getBasePlugins = ({
   development
 }) => [["@babel/plugin-transform-destructuring"], ["@babel/plugin-transform-react-jsx", {

package/dist/cjs/transformBabel.test.cjs

@@ -85,6 +85,23 @@ var import_transformBabel = require("./transformBabel.cjs");
     (0, import_vitest.expect)(result?.code).toContain("codegenNativeComponent('VirtualView')");
     (0, import_vitest.expect)(result?.code).not.toContain("HostComponent");
   });
+  (0, import_vitest.it)("preserves React Native Flow enums as runtime values", async () => {
+    const result = await (0, import_transformBabel.transformBabel)("/project/VirtualView.js", `
+        // @flow strict-local
+        export enum VirtualViewRenderState {
+          Unknown = 0,
+          Rendered = 1,
+          None = 2,
+        }
+
+        export const rendered = VirtualViewRenderState.Rendered
+      `, {
+      plugins: []
+    });
+    (0, import_vitest.expect)(result?.code).toContain("const VirtualViewRenderState =");
+    (0, import_vitest.expect)(result?.code).toContain("Rendered: 1");
+    (0, import_vitest.expect)(result?.code).toContain("VirtualViewRenderState.Rendered");
+  });
   (0, import_vitest.it)("rejects a required transform error instead of returning untransformed source", async () => {
     const negativeControl = () => ({
       visitor: {
@@ -123,6 +140,24 @@ var import_transformBabel = require("./transformBabel.cjs");
     const result = await (0, import_transformBabel.transformOxcReactCompiler)("/project/Counter.tsx", componentCode, "18", false);
     (0, import_vitest.expect)(result.code).toContain("_c(");
   });
+  (0, import_vitest.it)("supports mutating useSharedValue in useEffect via Reanimated environment defaults", async () => {
+    const reanimatedCode = `
+      import { useEffect } from 'react'
+      import { useSharedValue } from 'react-native-reanimated'
+
+      export function ReanimatedComponent() {
+        const val = useSharedValue(0)
+        useEffect(() => {
+          val.value = 1
+        }, [val])
+        return <div>{val.value}</div>
+      }
+    `;
+    const result = await (0, import_transformBabel.transformOxcReactCompiler)("/project/ReanimatedComponent.tsx", reanimatedCode, {
+      target: "19"
+    }, false);
+    (0, import_vitest.expect)(result.code).toContain("_c(");
+  });
 });
 (0, import_vitest.describe)("compiler plugin multi-stage source map composition", () => {
   (0, import_vitest.it)("composes earlier compiler maps when Babel also runs", async () => {
@@ -357,4 +392,278 @@ export async function* generatorProbe() {
       });
     }
   });
+});
+(0, import_vitest.describe)("findUserBabelConfig and user Babel config respect", () => {
+  (0, import_vitest.it)("finds user babel config and ignores generated configs", () => {
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-conf-")));
+    try {
+      (0, import_vitest.expect)((0, import_transformBabel.findUserBabelConfig)(projectRoot)).toBeNull();
+      const generatedFile = import_node_path.default.join(projectRoot, "babel.config.js");
+      import_node_fs.default.writeFileSync(generatedFile, "// @one-generated\nmodule.exports = {}");
+      (0, import_vitest.expect)((0, import_transformBabel.findUserBabelConfig)(projectRoot)).toBeNull();
+      import_node_fs.default.writeFileSync(generatedFile, "module.exports = { plugins: [] }");
+      (0, import_vitest.expect)((0, import_transformBabel.findUserBabelConfig)(projectRoot)).toBe(generatedFile);
+    } finally {
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  (0, import_vitest.it)("includes user configFile and babelrc in getBabelOptions for project files", () => {
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-conf-")));
+    const userConfig = import_node_path.default.join(projectRoot, "babel.config.json");
+    import_node_fs.default.writeFileSync(userConfig, '{"plugins": []}');
+    try {
+      const projectFileOptions = (0, import_transformBabel.getBabelOptions)({
+        id: import_node_path.default.join(projectRoot, "src", "index.tsx"),
+        code: `export const hello = () => 123`,
+        projectRoot,
+        development: true,
+        environment: "client",
+        reactForRNVersion: "19"
+      });
+      (0, import_vitest.expect)(projectFileOptions?.configFile).toBe(userConfig);
+      (0, import_vitest.expect)(projectFileOptions?.babelrc).toBe(true);
+      const nodeModulesOptions = (0, import_transformBabel.getBabelOptions)({
+        id: import_node_path.default.join(projectRoot, "node_modules", "foo", "index.js"),
+        code: `export const foo = 1`,
+        projectRoot,
+        development: true,
+        environment: "client",
+        reactForRNVersion: "19"
+      });
+      (0, import_vitest.expect)(nodeModulesOptions).toBeNull();
+    } finally {
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  (0, import_vitest.it)("runs user babel config transforms via transformBabel", async () => {
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-conf-")));
+    const userConfig = import_node_path.default.join(projectRoot, "babel.config.json");
+    import_node_fs.default.writeFileSync(userConfig, JSON.stringify({
+      comments: false
+    }));
+    try {
+      const code = "/* remove me */ export const x = 1";
+      const res = await (0, import_transformBabel.transformBabel)(import_node_path.default.join(projectRoot, "src", "index.ts"), code, {
+        configFile: userConfig,
+        babelrc: true
+      });
+      (0, import_vitest.expect)(res.code).not.toContain("remove me");
+      (0, import_vitest.expect)(res.code).toContain("export const x = 1");
+    } finally {
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+(0, import_vitest.describe)("explicit swc/oxc per-file choice with a user babel config", () => {
+  (0, import_vitest.it)("returns null for swc/oxc string and object forms", () => {
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-conf-")));
+    const userConfig = import_node_path.default.join(projectRoot, "babel.config.js");
+    import_node_fs.default.writeFileSync(userConfig, "module.exports = { plugins: [] }");
+    try {
+      const base = {
+        id: import_node_path.default.join(projectRoot, "src", "index.tsx"),
+        code: `export const x = 1`,
+        projectRoot,
+        development: true,
+        environment: "client",
+        reactForRNVersion: "19"
+      };
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)({
+        ...base,
+        userSetting: "swc"
+      })).toBeNull();
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)({
+        ...base,
+        userSetting: "oxc"
+      })).toBeNull();
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)({
+        ...base,
+        userSetting: {
+          transform: "swc"
+        }
+      })).toBeNull();
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)({
+        ...base,
+        userSetting: {
+          transform: "oxc"
+        }
+      })).toBeNull();
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)({
+        ...base,
+        userSetting: "babel"
+      })?.configFile).toBe(userConfig);
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)({
+        ...base,
+        userSetting: {
+          transform: "babel"
+        }
+      })?.configFile).toBe(userConfig);
+      (0, import_vitest.expect)((0, import_transformBabel.getBabelOptions)(base)?.configFile).toBe(userConfig);
+    } finally {
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  (0, import_vitest.it)("skips the transform end-to-end for object-form swc", async () => {
+    const {
+      createVXRNCompilerPlugin
+    } = await import("./index");
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-conf-")));
+    const srcDir = import_node_path.default.join(projectRoot, "src");
+    import_node_fs.default.mkdirSync(srcDir, {
+      recursive: true
+    });
+    const file = import_node_path.default.join(srcDir, "index.ts");
+    const code = `export const x = 1`;
+    import_node_fs.default.writeFileSync(file, code);
+    import_node_fs.default.writeFileSync(import_node_path.default.join(projectRoot, "babel.config.js"), "module.exports = { plugins: [] }");
+    (0, import_configure.configureVXRNCompilerPlugin)({
+      enableCompiler: false,
+      enableReanimated: false
+    });
+    try {
+      const plugins = await createVXRNCompilerPlugin({
+        transform: () => ({
+          transform: "swc"
+        })
+      });
+      const plugin = plugins.find(p => p.name === "one:compiler");
+      await plugin.configResolved({
+        root: projectRoot,
+        build: {}
+      });
+      const hook = plugin.transform.handler || plugin.transform;
+      const result = await hook.call({
+        environment: {
+          name: "client"
+        }
+      }, code, file);
+      (0, import_vitest.expect)(result == null).toBe(true);
+    } finally {
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableCompiler: false,
+        enableReanimated: false
+      });
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+(0, import_vitest.describe)("user babel config end-to-end through the compiler plugin", () => {
+  (0, import_vitest.it)("runs the user config when default plugins are empty", async () => {
+    const {
+      createVXRNCompilerPlugin
+    } = await import("./index");
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-e2e-")));
+    const srcDir = import_node_path.default.join(projectRoot, "src");
+    import_node_fs.default.mkdirSync(srcDir, {
+      recursive: true
+    });
+    const file = import_node_path.default.join(srcDir, "index.ts");
+    const marker = "babel-e2e-probe";
+    const code = `/* ${marker} */ export const x = 1`;
+    import_node_fs.default.writeFileSync(file, code);
+    import_node_fs.default.writeFileSync(import_node_path.default.join(projectRoot, "babel.config.json"), JSON.stringify({
+      comments: false
+    }));
+    (0, import_configure.configureVXRNCompilerPlugin)({
+      enableCompiler: false,
+      enableReanimated: false
+    });
+    try {
+      const plugins = await createVXRNCompilerPlugin();
+      const plugin = plugins.find(p => p.name === "one:compiler");
+      await plugin.configResolved({
+        root: projectRoot,
+        build: {}
+      });
+      const hook = plugin.transform.handler || plugin.transform;
+      const result = await hook.call({
+        environment: {
+          name: "client"
+        }
+      }, code, file);
+      (0, import_vitest.expect)(result).toBeDefined();
+      (0, import_vitest.expect)(result.code).toContain("export const x = 1");
+      (0, import_vitest.expect)(result.code).not.toContain(marker);
+    } finally {
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableCompiler: false,
+        enableReanimated: false
+      });
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  (0, import_vitest.it)("invalidates the cache when the user babel config is added or edited", async () => {
+    const {
+      createVXRNCompilerPlugin
+    } = await import("./index");
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-babel-cache-")));
+    const srcDir = import_node_path.default.join(projectRoot, "src");
+    import_node_fs.default.mkdirSync(srcDir, {
+      recursive: true
+    });
+    const file = import_node_path.default.join(srcDir, "index.ts");
+    const marker = "babel-cache-probe";
+    const code = `/* ${marker} */ export const x = 1`;
+    import_node_fs.default.writeFileSync(file, code);
+    const userConfig = import_node_path.default.join(projectRoot, "babel.config.json");
+    (0, import_configure.configureVXRNCompilerPlugin)({
+      enableCompiler: false,
+      enableReanimated: false
+    });
+    try {
+      const plugins = await createVXRNCompilerPlugin({
+        transform: () => "babel"
+      });
+      const plugin = plugins.find(p => p.name === "one:compiler");
+      await plugin.configResolved({
+        root: projectRoot,
+        build: {}
+      });
+      const hook = plugin.transform.handler || plugin.transform;
+      const context = {
+        environment: {
+          name: "client"
+        }
+      };
+      const res1 = await hook.call(context, code, file);
+      (0, import_vitest.expect)(res1.code).toContain(marker);
+      import_node_fs.default.writeFileSync(userConfig, JSON.stringify({
+        comments: false
+      }));
+      const res2 = await hook.call(context, code, file);
+      (0, import_vitest.expect)(res2.code).not.toContain(marker);
+      import_node_fs.default.writeFileSync(userConfig, JSON.stringify({
+        comments: true
+      }));
+      const res3 = await hook.call(context, code, file);
+      (0, import_vitest.expect)(res3.code).toContain(marker);
+    } finally {
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableCompiler: false,
+        enableReanimated: false
+      });
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
 });

package/dist/cjs/transformWorklets.test.cjs

@@ -24,6 +24,7 @@ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
 }) : target, mod));
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
+var import_node_module = require("node:module");
 var import_node_path = __toESM(require("node:path"), 1);
 var import_vitest = require("vitest");
 var import_configure = require("./configure.cjs");
@@ -322,7 +323,8 @@ var ${innerVar[1]} = {`);
     (0, import_vitest.expect)(typeof scaleFn).toBe("function");
     (0, import_vitest.expect)(scaleFn.__workletHash).toBeDefined();
     (0, import_vitest.expect)(typeof scaleFn.__workletHash).toBe("number");
-    (0, import_vitest.expect)(scaleFn.__pluginVersion).toBe("0.10.1");
+    const installedWorklets = (0, import_node_module.createRequire)(import_node_path.default.resolve(process.cwd(), "package.json"))("react-native-worklets/package.json").version;
+    (0, import_vitest.expect)(scaleFn.__pluginVersion).toBe(installedWorklets);
     (0, import_vitest.expect)(scaleFn.__closure).toEqual({
       multiplier: 5
     });

package/dist/esm/cache.mjs

@@ -17,30 +17,44 @@ function getCacheDir() {
   }
   return cacheDir;
 }
-function getConfigFingerprint() {
+function getConfigFingerprint(userBabelConfigPath) {
   return createHash("sha1").update(JSON.stringify({
     compiler: configuration.enableCompiler,
     reanimated: configuration.enableReanimated,
     nativeWorklets: isNativeWorkletsEnabled(),
     nativewind: configuration.enableNativewind,
     nativeCSS: configuration.enableNativeCSS,
+    // transform output depends on the user babel config when one applies,
+    // so its identity joins the fingerprint. adding, removing, or editing
+    // babel.config.* must miss entries written without that change.
+    babelConfig: getBabelConfigIdentity(userBabelConfigPath),
     // bump when the transform engine changes, so entries written by a
     // previous engine aren't served for the same source
     engine: "oxc-worklets-hermes-async"
   })).digest("hex").slice(0, 8);
 }
-function getCacheKey(filePath, environment) {
-  const hash = createHash("sha1").update(`${environment}:${filePath}:${getConfigFingerprint()}`).digest("hex");
+function getBabelConfigIdentity(configPath) {
+  if (!configPath) return null;
+  try {
+    const mtime = statSync(configPath).mtimeMs;
+    const hash = createHash("sha1").update(readFileSync(configPath)).digest("hex").slice(0, 16);
+    return `${configPath}:${mtime}:${hash}`;
+  } catch {
+    return configPath;
+  }
+}
+function getCacheKey(filePath, environment, userBabelConfigPath) {
+  const hash = createHash("sha1").update(`${environment}:${filePath}:${getConfigFingerprint(userBabelConfigPath)}`).digest("hex");
   return hash;
 }
 function getContentHash(code) {
   return createHash("sha1").update(code).digest("hex").slice(0, 16);
 }
-function getCachedTransform(filePath, code, environment) {
+function getCachedTransform(filePath, code, environment, userBabelConfigPath) {
   try {
     const cleanPath = filePath.startsWith("\0") ? filePath.slice(1) : filePath;
     const cacheDir = getCacheDir();
-    const cacheKey = getCacheKey(cleanPath, environment);
+    const cacheKey = getCacheKey(cleanPath, environment, userBabelConfigPath);
     const cachePath = join(cacheDir, `${cacheKey}.json`);
     if (!existsSync(cachePath)) {
       stats.misses++;
@@ -67,11 +81,11 @@ function getCachedTransform(filePath, code, environment) {
     return null;
   }
 }
-function setCachedTransform(filePath, code, result, environment) {
+function setCachedTransform(filePath, code, result, environment, userBabelConfigPath) {
   try {
     const cleanPath = filePath.startsWith("\0") ? filePath.slice(1) : filePath;
     const cacheDir = getCacheDir();
-    const cacheKey = getCacheKey(cleanPath, environment);
+    const cacheKey = getCacheKey(cleanPath, environment, userBabelConfigPath);
     const cachePath = join(cacheDir, `${cacheKey}.json`);
     const mtime = statSync(cleanPath).mtimeMs;
     const hash = getContentHash(code);