@vxrn/vite-plugin-metro 2.0.0-beta.33.1 → 2.0.0-beta.45.1

package/dist/esm/transformer/metroNativeWorker.test.mjs

@@ -1,861 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import * as vm from "node:vm";
-import { parseSync } from "oxc-parser";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createRequire } from "node:module";
-import { applyEnvironmentGuard, applyInlineEnvVars, assertNoUnportedBabelPlugins, extractDependencies, getCacheKey, getRemoveServerCodeRouterRoot, transform, wrapModule } from "./metroNativeWorker.mjs";
-import { buildMetroConfigInputFromViteConfig } from "../metro-config/getMetroConfigFromViteConfig.mjs";
-var __require = /* @__PURE__ */(x => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function (x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
-});
-const babelCalls = {
-  transform: 0,
-  transformSync: 0,
-  transformAsync: 0,
-  transformFromAstSync: 0,
-  parse: 0,
-  parseSync: 0
-};
-vi.mock("@babel/core", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    transform: vi.fn((...args) => {
-      babelCalls.transform++;
-      return actual.transform(...args);
-    }),
-    transformSync: vi.fn((...args) => {
-      babelCalls.transformSync++;
-      return actual.transformSync(...args);
-    }),
-    transformAsync: vi.fn((...args) => {
-      babelCalls.transformAsync++;
-      return actual.transformAsync(...args);
-    }),
-    transformFromAstSync: vi.fn((...args) => {
-      babelCalls.transformFromAstSync++;
-      return actual.transformFromAstSync(...args);
-    }),
-    parse: vi.fn((...args) => {
-      babelCalls.parse++;
-      return actual.parse(...args);
-    }),
-    parseSync: vi.fn((...args) => {
-      babelCalls.parseSync++;
-      return actual.parseSync(...args);
-    })
-  };
-});
-beforeEach(() => {
-  babelCalls.transform = 0;
-  babelCalls.transformSync = 0;
-  babelCalls.transformAsync = 0;
-  babelCalls.transformFromAstSync = 0;
-  babelCalls.parse = 0;
-  babelCalls.parseSync = 0;
-});
-function assertZeroBabelCalls() {
-  expect(babelCalls.transform).toBe(0);
-  expect(babelCalls.transformSync).toBe(0);
-  expect(babelCalls.transformAsync).toBe(0);
-  expect(babelCalls.transformFromAstSync).toBe(0);
-  expect(babelCalls.parse).toBe(0);
-  expect(babelCalls.parseSync).toBe(0);
-}
-describe("metroNativeWorker", () => {
-  it.each([["data.json", true], ["data.json", false], ["data.js", false]])("minifies %s with source maps enabled=%s without stale mappings", async (filename, sourceMap) => {
-    const result = await transform({
-      minifierPath: createRequire(import.meta.url).resolve("metro-minify-terser"),
-      minifierConfig: {
-        sourceMap
-      }
-    }, "/project", filename, Buffer.from(filename.endsWith(".json") ? "{\"answer\":42}" : "module.exports = { answer: 42 }"), {
-      dev: false,
-      minify: true,
-      platform: "ios",
-      type: "module"
-    });
-    const module = {
-      exports: {}
-    };
-    const {
-      code,
-      map
-    } = result.output[0].data;
-    vm.runInNewContext(code, {
-      __d(factory) {
-        factory({}, () => {}, () => {}, () => {}, module, module.exports, []);
-      }
-    });
-    expect(module.exports.answer).toBe(42);
-    expect(map.every(entry => entry.length === 2)).toBe(true);
-    assertZeroBabelCalls();
-  });
-  it("minifies production modules with executable output and original source locations", async () => {
-    const source = "exports.answer = function answer(value) {\n  return value + 42\n}\n";
-    const {
-      code,
-      map
-    } = (await transform({
-      minifierPath: createRequire(import.meta.url).resolve("metro-minify-terser"),
-      minifierConfig: {
-        mangle: true
-      }
-    }, "/project", "answer.js", Buffer.from(source), {
-      dev: false,
-      minify: true,
-      platform: "ios",
-      type: "module"
-    })).output[0].data;
-    const module = {
-      exports: {}
-    };
-    vm.runInNewContext(code, {
-      __d(factory) {
-        factory({}, () => {}, () => {}, () => {}, module, module.exports, []);
-      }
-    });
-    expect(module.exports.answer(8)).toBe(50);
-    const msm = await import("metro-source-map");
-    const fullMap = msm.fromRawMappings([{
-      code,
-      path: "answer.js",
-      source,
-      map
-    }]).toMap();
-    const offset = code.indexOf("42");
-    expect(offset).toBeGreaterThan(-1);
-    const prefix = code.slice(0, offset).split("\n");
-    const position = new msm.Consumer(fullMap).originalPositionFor({
-      line: prefix.length,
-      column: prefix.at(-1).length
-    });
-    expect(position.source).toBe("answer.js");
-    expect(position.line).toBe(2);
-    expect(position.column).toBe(17);
-    assertZeroBabelCalls();
-  });
-  it("extracts all dependencies with oxc-parser and zero Babel", () => {
-    const deps = extractDependencies(`
-      import React, { useState } from 'react'
-      import * as RN from 'react-native'
-      import './global.css'
-      import type { UserType } from './user-types'
-      export { Button } from './Button'
-      export * from './icons'
-      export type { ThemeType } from './theme-types'
-      const helper = require('./helper')
-      async function loadAsync() {
-        const dyn = await import('./dynamic-module')
-      }
-    `, "TestComponent.tsx");
-    assertZeroBabelCalls();
-    const names = deps.map(d => d.name);
-    expect(names).toContain("react");
-    expect(names).toContain("react-native");
-    expect(names).toContain("./global.css");
-    expect(names).toContain("./Button");
-    expect(names).toContain("./icons");
-    expect(names).toContain("./helper");
-    expect(names).toContain("./dynamic-module");
-    expect(names).not.toContain("./user-types");
-    expect(names).not.toContain("./theme-types");
-    const reactDep = deps.find(d => d.name === "react");
-    expect(reactDep.data.isESMImportAtSource).toBe(true);
-    expect(reactDep.data.asyncType).toBeNull();
-    expect(reactDep.data.locs.length).toBeGreaterThan(0);
-    const loc = reactDep.data.locs[0];
-    expect(loc.start.line).toBeGreaterThan(0);
-    expect(loc.start.column).toBeGreaterThanOrEqual(0);
-    expect(loc.end.line).toBeGreaterThanOrEqual(loc.start.line);
-    expect(loc.end.column).toBeGreaterThanOrEqual(0);
-    const helperDep = deps.find(d => d.name === "./helper");
-    expect(helperDep.data.isESMImportAtSource).toBe(false);
-    expect(helperDep.data.asyncType).toBeNull();
-    expect(deps.find(d => d.name === "./dynamic-module").data.asyncType).toBe("async");
-  });
-  it("marks requires inside a try block optional", () => {
-    const code = `
-      let worklets
-      try {
-        worklets = require('react-native-worklets-core')
-      } catch {}
-      const always = require('./always-there')
-    `;
-    expect(extractDependencies(code, "setup.js").find(d => d.name === "react-native-worklets-core").data.isOptional).toBeUndefined();
-    const on = extractDependencies(code, "setup.js", {
-      allowOptionalDependencies: true
-    });
-    expect(on.find(d => d.name === "react-native-worklets-core").data.isOptional).toBe(true);
-    expect(on.find(d => d.name === "./always-there").data.isOptional).toBeUndefined();
-    expect(extractDependencies(code, "setup.js", {
-      allowOptionalDependencies: {
-        exclude: ["react-native-worklets-core"]
-      }
-    }).find(d => d.name === "react-native-worklets-core").data.isOptional).toBeUndefined();
-  });
-  it("wraps modules in Metro CommonJS format with and without moduleId", () => {
-    const code = "exports.val = 123;";
-    const wrappedWithoutId = wrapModule(code);
-    expect(wrappedWithoutId).toContain("__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {");
-    expect(wrappedWithoutId).toContain("var require = _$$_REQUIRE;");
-    expect(wrappedWithoutId).toContain("exports.val = 123;");
-    expect(wrappedWithoutId.endsWith(");")).toBe(true);
-    expect(wrapModule(code, {
-      moduleId: 99,
-      dependencyIds: [1, 2, 3]
-    })).toContain(", 99, [1,2,3]);");
-  });
-  it("transforms TSX with React JSX, Hermes lowering, and ZERO Babel", async () => {
-    const result = await transform({}, "/project", "Greeter.tsx", Buffer.from(`
-      import React from 'react'
-      import { View, Text } from 'react-native'
-      const helper = require('./helper')
-
-      export class Greeter extends React.Component {
-        greeting = 'Hello from Native'
-
-        async fetchGreeting() {
-          return this.greeting
-        }
-
-        render() {
-          return (
-            <View testID="greeter">
-              <Text>{this.greeting}</Text>
-            </View>
-          )
-        }
-      }
-    `, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    expect(result.output).toHaveLength(1);
-    const output = result.output[0];
-    expect(output.type).toBe("js/module");
-    expect(output.data.lineCount).toBeGreaterThan(0);
-    expect(output.data.map.length).toBeGreaterThan(0);
-    const code = output.data.code;
-    expect(code).toContain("__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {");
-    expect(code).toContain("var require = _$$_REQUIRE;");
-    expect(code).not.toContain("<View");
-    expect(code).not.toContain("<Text");
-    expect(code).toContain("this.greeting = \"Hello from Native\"");
-    const depNames = result.dependencies.map(d => d.name);
-    expect(depNames).toContain("react");
-    expect(depNames).toContain("react-native");
-    expect(depNames).toContain("./helper");
-    expect(depNames).toContain("react/jsx-dev-runtime");
-  });
-  it("lowers async generators, including the method shorthand Hermes also rejects", async () => {
-    for (const [filename, sourceCode] of Object.entries({
-      "cursor.ts": `
-        export class Cursor {
-          async *rows() {
-            yield await Promise.resolve(1)
-          }
-        }
-      `,
-      "stream.ts": `
-        export async function* stream() {
-          yield 1
-        }
-      `,
-      "drain.ts": `
-        export async function drain(src) {
-          for await (const x of src) {
-            console.log(x)
-          }
-        }
-      `
-    })) {
-      const result = await transform({}, "/project", filename, Buffer.from(sourceCode, "utf8"), {
-        dev: true,
-        platform: "ios",
-        type: "module"
-      });
-      assertZeroBabelCalls();
-      const code = result.output[0].data.code;
-      expect(code, filename).not.toMatch(/\basync\s+function\s*\*/);
-      expect(code, filename).not.toMatch(/\basync\s*\*\s*[\w$[]/);
-      expect(code, filename).not.toMatch(/\bfor\s+await\s*\(/);
-    }
-  });
-  it("handles JSON files without Babel", async () => {
-    const jsonSource = JSON.stringify({
-      name: "my-package",
-      version: "1.0.0"
-    });
-    const result = await transform({}, "/project", "package.json", Buffer.from(jsonSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    expect(result.dependencies).toEqual([]);
-    expect(result.output).toHaveLength(1);
-    expect(result.output[0].type).toBe("js/module");
-    expect(result.output[0].data.code).toContain("module.exports = {\"name\":\"my-package\",\"version\":\"1.0.0\"}");
-    expect(result.output[0].data.code).toContain("__d(function (global, require");
-  });
-  it("handles Asset files without Babel", async () => {
-    const result = await transform({
-      assetRegistryPath: "react-native/Libraries/Image/AssetRegistry",
-      publicPath: "/assets"
-    }, "/project", "logo.png", Buffer.from("fake-png-binary-data", "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "asset"
-    });
-    assertZeroBabelCalls();
-    expect(result.output[0].type).toBe("js/module/asset");
-    expect(result.output[0].data.code).toContain("registerAsset(");
-    expect(result.output[0].data.code).toContain("__d(function");
-    expect(result.dependencies.map(d => d.name)).toContain("react-native/Libraries/Image/AssetRegistry");
-  });
-  it("handles Flow files by stripping types without Babel", async () => {
-    const result = await transform({}, "/project", "math.js", Buffer.from(`
-      // @flow
-      function add(a: number, b: number): number {
-        return a + b;
-      }
-      export default add;
-    `, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    expect(result.output[0].data.code).not.toContain(": number");
-    expect(result.output[0].data.code).toContain("function add(a, b)");
-  });
-  it("generates a deterministic cache key without Babel", () => {
-    const key1 = getCacheKey({
-      globalPrefix: "__one_",
-      minifierPath: "terser"
-    }, {
-      projectRoot: "/app"
-    });
-    const key2 = getCacheKey({
-      globalPrefix: "__one_",
-      minifierPath: "terser"
-    }, {
-      projectRoot: "/app"
-    });
-    const key3 = getCacheKey({
-      globalPrefix: "__other_"
-    }, {
-      projectRoot: "/app"
-    });
-    assertZeroBabelCalls();
-    expect(key1).toBe(key2);
-    expect(key1).not.toBe(key3);
-    expect(typeof key1).toBe("string");
-    expect(key1.length).toBe(64);
-  });
-  it("correctly sets transformerPath in buildMetroConfigInputFromViteConfig when active", async () => {
-    const mockViteConfig = {
-      root: process.cwd()
-    };
-    delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-    const configDefault = await buildMetroConfigInputFromViteConfig(mockViteConfig, {});
-    expect(configDefault.defaultConfig.transformerPath).toContain("metroNativeWorker");
-    expect(configDefault.defaultConfig.transformer.transformerPath).toBeUndefined();
-    expect((await buildMetroConfigInputFromViteConfig(mockViteConfig, {
-      nativeTransforms: false
-    })).defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-    process.env.ONE_METRO_NATIVE_TRANSFORMS = "0";
-    expect((await buildMetroConfigInputFromViteConfig(mockViteConfig, {})).defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-    process.env.ONE_METRO_NATIVE_TRANSFORMS = "1";
-    expect((await buildMetroConfigInputFromViteConfig(mockViteConfig, {
-      nativeTransforms: false
-    })).defaultConfig.transformerPath).toContain("metroNativeWorker");
-    delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-  });
-  it("excludes volatile compiler caches from Metro without hiding package output", async () => {
-    const blockList = (await buildMetroConfigInputFromViteConfig({
-      root: process.cwd()
-    }, {
-      watchman: false
-    })).defaultConfig.resolver.blockList;
-    const isBlocked = file => blockList.some(pattern => pattern.test(file));
-    expect(isBlocked("/home/runner/work/one/one/tests/test-app-cases/node_modules/.vxrn/compiler-cache")).toBe(true);
-    expect(isBlocked("C:\\workspace\\tests\\test-app-cases\\node_modules\\.vxrn\\compiler-cache")).toBe(true);
-    expect(isBlocked("/home/runner/work/one/one/packages/one/dist/esm/index.mjs")).toBe(false);
-  });
-  it("transforms and executes a real 2-module Metro bundle through metro-runtime require polyfill", async () => {
-    const depSource = "exports.value = 42;";
-    const aSource = "const dep = require(\"./dep\"); module.exports = { doubled: dep.value * 2 };";
-    const depRes = await transform({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 2,
-      dependencyIds: []
-    });
-    const aRes = await transform({}, "/project", "a.js", Buffer.from(aSource, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: [2]
-    });
-    assertZeroBabelCalls();
-    expect(aRes.dependencies).toHaveLength(1);
-    expect(aRes.dependencies[0].name).toBe("./dep");
-    const aEmittedCode = aRes.output[0].data.code;
-    expect(aEmittedCode).toContain("require(_dependencyMap[0], \"./dep\")");
-    const polyfillPath = __require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: false,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(depRes.output[0].data.code, contextObj);
-    vm.runInContext(aEmittedCode, contextObj);
-    expect(vm.runInContext("global.__r(1)", contextObj)).toEqual({
-      doubled: 84
-    });
-  });
-  it("transforms and executes a 2-module Metro bundle with ESM imports in dev mode", async () => {
-    const depSource = "export const greeting = \"Hello Metro Native\";";
-    const aSource = "import { greeting } from \"./dep\"; export const message = greeting.toUpperCase();";
-    const depRes = await transform({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 2,
-      dependencyIds: []
-    });
-    const aRes = await transform({}, "/project", "a.js", Buffer.from(aSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: [2]
-    });
-    assertZeroBabelCalls();
-    const polyfillPath = __require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: true,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(depRes.output[0].data.code, contextObj);
-    vm.runInContext(aRes.output[0].data.code, contextObj);
-    expect(vm.runInContext("global.__r(1)", contextObj).message).toBe("HELLO METRO NATIVE");
-  });
-  it("respects lexical scope shadowing for require calls (Astra probe)", async () => {
-    const res = await transform({}, "/project", "shadowed.js", Buffer.from("function f(require){return require(\"./local\")}; module.exports=f(x=>x);", "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: []
-    });
-    assertZeroBabelCalls();
-    expect(res.dependencies).toHaveLength(0);
-    const emitted = res.output[0].data.code;
-    expect(emitted).not.toContain("_dependencyMap[0]");
-    expect(emitted).toMatch(/require\d*\("\.\/local"\)/);
-    const polyfillPath = __require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: false,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(emitted, contextObj);
-    expect(vm.runInContext("global.__r(1)", contextObj)).toBe("./local");
-  });
-  it("preserves distinct indexed identity for duplicate and mixed sync/async dependencies", async () => {
-    const res = await transform({}, "/project", "index.js", Buffer.from(`
-      const a = require('./dep');
-      const b = require('./dep');
-      async function load() {
-        const c = await import('./dep');
-      }
-    `, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    expect(res.dependencies.map(d => d.name)).toContain("./dep");
-    const syncDep = res.dependencies.find(d => d.name === "./dep" && d.data.asyncType === null);
-    const asyncDep = res.dependencies.find(d => d.name === "./dep" && d.data.asyncType === "async");
-    expect(syncDep).toBeDefined();
-    expect(asyncDep).toBeDefined();
-    expect(syncDep.data.index).not.toEqual(asyncDep.data.index);
-    const emitted = res.output[0].data.code;
-    const syncIndex = syncDep.data.index;
-    expect(emitted).toContain(`require(_dependencyMap[${syncIndex}], "./dep")`);
-  });
-  it("conforms to Metro map ABI with raw mapping segment tuples and accurate symbolication", async () => {
-    const res = await transform({}, "/project", "math.ts", Buffer.from(`
-      export function add(a: number, b: number): number {
-        return a + b;
-      }
-    `, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    const map = res.output[0].data.map;
-    expect(Array.isArray(map)).toBe(true);
-    expect(map.length).toBeGreaterThan(0);
-    for (const tuple of map) {
-      expect(Array.isArray(tuple)).toBe(true);
-      expect(typeof tuple[0]).toBe("number");
-      expect(typeof tuple[1]).toBe("number");
-      expect(tuple).not.toHaveProperty("version");
-      expect(tuple).not.toHaveProperty("mappings");
-    }
-    const msm = await import("metro-source-map");
-    const fullMap = msm.fromRawMappings([{
-      code: res.output[0].data.code,
-      source: "math.ts",
-      map
-    }]).toMap();
-    const consumer = new msm.Consumer(fullMap);
-    const addLineIndex = res.output[0].data.code.split("\n").findIndex(l => l.includes("function add"));
-    expect(addLineIndex).toBeGreaterThan(0);
-    expect(consumer.originalPositionFor({
-      line: addLineIndex + 1,
-      column: 16
-    }).line).toBe(2);
-  });
-  it("models JS hoisting in ScopeTracker for functions and vars (Astra probe)", async () => {
-    const res = await transform({}, "/project", "hoisted.js", Buffer.from("function f(){const x=require(\"./local\"); function require(x){return x}; return x} module.exports=f();", "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: []
-    });
-    assertZeroBabelCalls();
-    expect(res.dependencies).toHaveLength(0);
-    const emitted = res.output[0].data.code;
-    expect(emitted).not.toContain("_dependencyMap[0]");
-    expect(emitted).toMatch(/require\d*\("\.\/local"\)/);
-    const polyfillPath = __require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: false,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(emitted, contextObj);
-    expect(vm.runInContext("global.__r(1)", contextObj)).toBe("./local");
-  });
-  it("rewrites dynamic import to Metro asyncRequire and executes promise resolution in dev and release", async () => {
-    const depSource = "exports.message = \"hello dynamic\";";
-    const mainSource = "module.exports = () => import(\"./dep\");";
-    const depRes = await transform({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 2,
-      dependencyIds: []
-    });
-    const mainRes = await transform({}, "/project", "main.js", Buffer.from(mainSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 0,
-      dependencyIds: [2, 1]
-    });
-    assertZeroBabelCalls();
-    const depNames = mainRes.dependencies.map(d => d.name);
-    expect(depNames).toContain("./dep");
-    expect(depNames).toContain("metro-runtime/src/modules/asyncRequire");
-    expect(mainRes.dependencies.find(d => d.name === "./dep").data.asyncType).toBe("async");
-    const emittedMain = mainRes.output[0].data.code;
-    expect(emittedMain).not.toContain("import(\"./dep\")");
-    expect(emittedMain).toContain("require(_dependencyMap[1], \"metro-runtime/src/modules/asyncRequire\")(_dependencyMap[0], _dependencyMap.paths, \"./dep\")");
-    const polyfillPath = __require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const asyncRequirePath = __require.resolve("metro-runtime/src/modules/asyncRequire.js");
-    const wrappedAsyncRequire = wrapModule(fs.readFileSync(asyncRequirePath, "utf8"), {
-      moduleId: 1,
-      dependencyIds: []
-    });
-    for (const isDev of [true, false]) {
-      const contextObj = {
-        __DEV__: isDev,
-        __METRO_GLOBAL_PREFIX__: "",
-        console
-      };
-      contextObj.global = contextObj;
-      vm.createContext(contextObj);
-      vm.runInContext(polyfillCode, contextObj);
-      vm.runInContext(wrappedAsyncRequire, contextObj);
-      vm.runInContext(depRes.output[0].data.code, contextObj);
-      vm.runInContext(emittedMain, contextObj);
-      const mainFn = vm.runInContext("global.__r(0)", contextObj);
-      expect(typeof mainFn).toBe("function");
-      const promise = mainFn();
-      expect(promise instanceof Promise || promise && typeof promise.then === "function").toBe(true);
-      const resolved = await promise;
-      expect(resolved.message).toBe("hello dynamic");
-      expect(resolved.default.message).toBe("hello dynamic");
-    }
-  });
-  it("preserves accurate sourcemap for tokens after rewritten require calls on the same line", async () => {
-    const sourceCode = "const a = require(\"./dep\"), b = 42;";
-    const resWrapped = await transform({}, "/project", "app.js", Buffer.from(sourceCode, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    const msm = await import("metro-source-map");
-    const fullMapWrapped = msm.fromRawMappings([{
-      code: resWrapped.output[0].data.code,
-      source: "app.js",
-      map: resWrapped.output[0].data.map
-    }]).toMap();
-    const consumerWrapped = new msm.Consumer(fullMapWrapped);
-    const linesWrapped = resWrapped.output[0].data.code.split("\n");
-    const lineIndexWrapped = linesWrapped.findIndex(l => l.includes("b = 42"));
-    expect(lineIndexWrapped).toBeGreaterThanOrEqual(0);
-    const generatedColWrapped = linesWrapped[lineIndexWrapped].indexOf("b = 42");
-    expect(generatedColWrapped).toBeGreaterThan(0);
-    const posWrapped = consumerWrapped.originalPositionFor({
-      line: lineIndexWrapped + 1,
-      column: generatedColWrapped
-    });
-    expect(posWrapped.line).toBe(1);
-    expect(posWrapped.column).toBe(28);
-    expect(sourceCode.slice(Number(posWrapped.column))).toContain("b = 42;");
-    const resUnwrapped = await transform({
-      unstable_disableModuleWrapping: true
-    }, "/project", "app.js", Buffer.from(sourceCode, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    const fullMapUnwrapped = msm.fromRawMappings([{
-      code: resUnwrapped.output[0].data.code,
-      source: "app.js",
-      map: resUnwrapped.output[0].data.map
-    }]).toMap();
-    const consumerUnwrapped = new msm.Consumer(fullMapUnwrapped);
-    const linesUnwrapped = resUnwrapped.output[0].data.code.split("\n");
-    const lineIndexUnwrapped = linesUnwrapped.findIndex(l => l.includes("b = 42"));
-    expect(lineIndexUnwrapped).toBeGreaterThanOrEqual(0);
-    const generatedColUnwrapped = linesUnwrapped[lineIndexUnwrapped].indexOf("b = 42");
-    const posUnwrapped = consumerUnwrapped.originalPositionFor({
-      line: lineIndexUnwrapped + 1,
-      column: generatedColUnwrapped
-    });
-    expect(posUnwrapped.line).toBe(1);
-    expect(posUnwrapped.column).toBe(28);
-  });
-  it("routes a require.context whose directory is held in a variable through the dependency map", async () => {
-    const result = await transform({}, "/project", "entry.js", Buffer.from(`
-      const routeRoot = './app'
-      export const ctx = require.context(routeRoot, true, /\\.tsx$/)
-    `, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    });
-    expect(result.dependencies.find(d => d.data.contextParams != null)?.name).toBe("./app");
-    const calls = [];
-    let ctx;
-    vm.runInNewContext(result.output[0].data.code, {
-      __d: factory => {
-        const module = {
-          exports: {}
-        };
-        const req = (...args) => {
-          calls.push(args);
-          return {
-            keys: () => []
-          };
-        };
-        req.context = () => {
-          throw new Error("fallbackRequireContext reached");
-        };
-        factory({}, req, () => ({}), () => ({}), module, module.exports, ["./app"]);
-        ctx = module.exports.ctx;
-      }
-    });
-    expect(ctx).toBeDefined();
-    expect(calls[0][1]).toBe("./app");
-  });
-  it("gives loop bodies per-iteration bindings that survive a runtime without them", async () => {
-    const asHermesWouldSeeIt = (await transform({}, "/project", "loops.ts", Buffer.from(`
-      export function collect() {
-        const out = []
-        for (let i = 0; i < 2; i++) out.push(() => i)
-        for (const label of ['a', 'b']) out.push(() => label)
-        for (const key in { x: 1, y: 2 }) out.push(() => key)
-        return out.map((f) => f())
-      }
-    `, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    })).output[0].data.code.replace(/\bfor\s*\(\s*(let|const)\b/g, "for (var");
-    let collect;
-    vm.runInNewContext(asHermesWouldSeeIt, {
-      __d: factory => {
-        const module = {
-          exports: {}
-        };
-        factory({}, () => ({}), () => ({}), () => ({}), module, module.exports, []);
-        collect = module.exports.collect;
-      }
-    });
-    expect(collect()).toEqual([0, 1, "a", "b", "x", "y"]);
-  });
-});
-describe("one native transform ports", () => {
-  it("inlines process.env.ONE_SERVER_URL so a native bundle can find its loaders", () => {
-    process.env.ONE_SERVER_URL = "https://example.test";
-    try {
-      expect(applyInlineEnvVars("export const url = process.env.ONE_SERVER_URL;", "loader.ts", false)).toBe("export const url = \"https://example.test\";");
-    } finally {
-      process.env.ONE_SERVER_URL = void 0;
-    }
-  });
-  it("leaves ONE_SERVER_URL alone when it is only a string", () => {
-    const src = "export const key = \"process.env.ONE_SERVER_URL\";";
-    expect(applyInlineEnvVars(src, "a.ts", false)).toBe(src);
-  });
-  it("inlines import.meta.env reads, which oxc otherwise lowers to an empty object", () => {
-    const out = applyInlineEnvVars(`export const key = import.meta.env.VITE_POSTHOG_API_KEY;
-export const target = import.meta.env?.TAMAGUI_TARGET;
-export const missing = import.meta.env.NOT_SET;
-export const all = { ...import.meta.env };`, "env.ts", true, {
-      DEV: false,
-      VITE_POSTHOG_API_KEY: "pk_live",
-      TAMAGUI_TARGET: "native"
-    });
-    expect(out).toContain("export const key = \"pk_live\";");
-    expect(out).toContain("export const target = \"native\";");
-    expect(out).toContain("export const missing = undefined;");
-    expect(out).toContain("\"VITE_POSTHOG_API_KEY\":\"pk_live\"");
-    expect(out).not.toContain("import.meta");
-  });
-  it("inlines process.env keys the vite env map defines", () => {
-    const out = applyInlineEnvVars("export const t = process.env.TAMAGUI_TARGET; export const u = process.env.UNKNOWN_THING;", "env.ts", true, {
-      TAMAGUI_TARGET: "native"
-    });
-    expect(out).toContain("export const t = \"native\";");
-    expect(out).toContain("process.env.UNKNOWN_THING");
-  });
-  it("never rewrites an env read in an assignment target", () => {
-    const src = "process.env.VITE_ENVIRONMENT = \"ssr\";";
-    expect(applyInlineEnvVars(src, "a.ts", true, {
-      VITE_ENVIRONMENT: "ios"
-    })).toBe(src);
-  });
-  it("folds branches the inlining made constant so metro never resolves dead imports", () => {
-    const out = applyInlineEnvVars(`if (import.meta.env.SSR) { require('./server-only-thing') } else { load(import.meta.env.API) }`, "branch.ts", true, {
-      SSR: false,
-      API: "https://api.test"
-    });
-    expect(out).not.toContain("server-only-thing");
-    expect(out).toContain("load(\"https://api.test\")");
-  });
-  it("folds a ternary and keeps a branch it cannot resolve", () => {
-    expect(applyInlineEnvVars("const a = import.meta.env.DEV ? x : y;", "a.ts", true, {
-      DEV: false
-    })).toContain("const a = y;");
-    const dynamic = "const a = flag ? x : y;";
-    expect(applyInlineEnvVars(dynamic, "a.ts", true, {
-      DEV: false
-    })).toBe(dynamic);
-  });
-  it("runs the user native transforms that stand in for their babel plugins", async () => {
-    const result = await transform({}, import.meta.dirname, "ota.ts", Buffer.from("export const id = __EXAMPLE_BUILD_ID; export const from = __EXAMPLE_FILENAME;", "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      customTransformOptions: {
-        vite: {
-          nativeTransformModules: ["./__fixtures__/exampleNativeTransform.cjs"]
-        }
-      }
-    });
-    assertZeroBabelCalls();
-    expect(result.output[0].data.code).toContain("\"ios-build\"");
-    expect(result.output[0].data.code).not.toContain("__EXAMPLE_BUILD_ID");
-    expect(result.output[0].data.code).toContain(JSON.stringify(path.join(import.meta.dirname, "ota.ts")));
-  });
-  it("refuses to build when a user babel plugin has no native port", () => {
-    const withPlugins = plugins => ({
-      customTransformOptions: {
-        vite: {
-          babelConfig: {
-            plugins
-          }
-        }
-      }
-    });
-    expect(() => assertNoUnportedBabelPlugins(withPlugins([["@vxrn/vite-plugin-metro/babel-plugins/import-meta-env-plugin", {
-      env: {}
-    }], "one/babel-plugin-environment-guard", "hot-updater/babel-plugin"]))).toThrow(/hot-updater\/babel-plugin/);
-    expect(() => assertNoUnportedBabelPlugins(withPlugins([["@vxrn/vite-plugin-metro/babel-plugins/import-meta-env-plugin", {
-      env: {}
-    }], "one/babel-plugin-environment-guard", ["one/babel-plugin-remove-server-code", {
-      routerRoot: "app"
-    }], ["babel-plugin-module-resolver", {
-      alias: {}
-    }], ["one/babel-plugin-one-router-metro", {}], "one/babel-plugin-inline-one-server-url", "babel-plugin-react-compiler", "react-native-reanimated/plugin"]))).not.toThrow();
-  });
-  it("turns a server-only import into a throw and drops native-only", () => {
-    const out = applyEnvironmentGuard(`import 'native-only'
-
-export const a = 1`, "route.ts");
-    expect(out).not.toContain("native-only");
-    expect(out).toContain("server-only cannot be imported in a native environment");
-    const parsed = parseSync("route.ts", out, {
-      lang: "ts"
-    });
-    expect(parsed.errors).toEqual([]);
-    expect(parsed.program.body.map(n => n.type)).toContain("ThrowStatement");
-  });
-  it("reads the router root off one's remove-server-code plugin entry", () => {
-    expect(getRemoveServerCodeRouterRoot({
-      customTransformOptions: {
-        vite: {
-          babelConfig: {
-            plugins: [["one/babel-plugin-remove-server-code", {
-              routerRoot: "src/app"
-            }]]
-          }
-        }
-      }
-    })).toBe("src/app");
-    expect(getRemoveServerCodeRouterRoot({
-      customTransformOptions: {}
-    })).toBe(void 0);
-  });
-});
-//# sourceMappingURL=metroNativeWorker.test.mjs.map