@vxrn/vite-plugin-metro 1.25.16 → 1.26.0

package/dist/cjs/transformer/metroNativeWorker.test.native.js

@@ -0,0 +1,995 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var import_vitest = require("vitest");
+var vm = __toESM(require("vm"), 1);
+var import_oxc_parser = require("oxc-parser");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_module = require("module");
+var import_metroNativeWorker = require("./metroNativeWorker.native.js");
+var import_getMetroConfigFromViteConfig = require("../metro-config/getMetroConfigFromViteConfig.native.js");
+const import_meta = {};
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);else return left instanceof right;
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var babelCalls = {
+  transform: 0,
+  transformSync: 0,
+  transformAsync: 0,
+  transformFromAstSync: 0,
+  parse: 0,
+  parseSync: 0
+};
+import_vitest.vi.mock("@babel/core", async function (importOriginal) {
+  var actual = await importOriginal();
+  return {
+    ...actual,
+    transform: import_vitest.vi.fn(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+      babelCalls.transform++;
+      return actual.transform(...args);
+    }),
+    transformSync: import_vitest.vi.fn(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+      babelCalls.transformSync++;
+      return actual.transformSync(...args);
+    }),
+    transformAsync: import_vitest.vi.fn(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+      babelCalls.transformAsync++;
+      return actual.transformAsync(...args);
+    }),
+    transformFromAstSync: import_vitest.vi.fn(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+      babelCalls.transformFromAstSync++;
+      return actual.transformFromAstSync(...args);
+    }),
+    parse: import_vitest.vi.fn(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+      babelCalls.parse++;
+      return actual.parse(...args);
+    }),
+    parseSync: import_vitest.vi.fn(function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+      babelCalls.parseSync++;
+      return actual.parseSync(...args);
+    })
+  };
+});
+(0, import_vitest.beforeEach)(function () {
+  babelCalls.transform = 0;
+  babelCalls.transformSync = 0;
+  babelCalls.transformAsync = 0;
+  babelCalls.transformFromAstSync = 0;
+  babelCalls.parse = 0;
+  babelCalls.parseSync = 0;
+});
+function assertZeroBabelCalls() {
+  (0, import_vitest.expect)(babelCalls.transform).toBe(0);
+  (0, import_vitest.expect)(babelCalls.transformSync).toBe(0);
+  (0, import_vitest.expect)(babelCalls.transformAsync).toBe(0);
+  (0, import_vitest.expect)(babelCalls.transformFromAstSync).toBe(0);
+  (0, import_vitest.expect)(babelCalls.parse).toBe(0);
+  (0, import_vitest.expect)(babelCalls.parseSync).toBe(0);
+}
+(0, import_vitest.describe)("metroNativeWorker", function () {
+  import_vitest.it.each([["data.json", true], ["data.json", false], ["data.js", false]])("minifies %s with source maps enabled=%s without stale mappings", async function (filename, sourceMap) {
+    var result = await (0, import_metroNativeWorker.transform)({
+      minifierPath: (0, import_module.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"
+    });
+    var module2 = {
+      exports: {}
+    };
+    var {
+      code,
+      map
+    } = result.output[0].data;
+    vm.runInNewContext(code, {
+      __d(factory) {
+        factory({}, function () {}, function () {}, function () {}, module2, module2.exports, []);
+      }
+    });
+    (0, import_vitest.expect)(module2.exports.answer).toBe(42);
+    (0, import_vitest.expect)(map.every(function (entry) {
+      return entry.length === 2;
+    })).toBe(true);
+    assertZeroBabelCalls();
+  });
+  (0, import_vitest.it)("minifies production modules with executable output and original source locations", async function () {
+    var source = "exports.answer = function answer(value) {\n  return value + 42\n}\n";
+    var {
+      code,
+      map
+    } = (await (0, import_metroNativeWorker.transform)({
+      minifierPath: (0, import_module.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;
+    var module2 = {
+      exports: {}
+    };
+    vm.runInNewContext(code, {
+      __d(factory) {
+        factory({}, function () {}, function () {}, function () {}, module2, module2.exports, []);
+      }
+    });
+    (0, import_vitest.expect)(module2.exports.answer(8)).toBe(50);
+    var msm = await import("metro-source-map");
+    var fullMap = msm.fromRawMappings([{
+      code,
+      path: "answer.js",
+      source,
+      map
+    }]).toMap();
+    var offset = code.indexOf("42");
+    (0, import_vitest.expect)(offset).toBeGreaterThan(-1);
+    var prefix = code.slice(0, offset).split("\n");
+    var position = new msm.Consumer(fullMap).originalPositionFor({
+      line: prefix.length,
+      column: prefix.at(-1).length
+    });
+    (0, import_vitest.expect)(position.source).toBe("answer.js");
+    (0, import_vitest.expect)(position.line).toBe(2);
+    (0, import_vitest.expect)(position.column).toBe(17);
+    assertZeroBabelCalls();
+  });
+  (0, import_vitest.it)("extracts all dependencies with oxc-parser and zero Babel", function () {
+    var deps = (0, import_metroNativeWorker.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();
+    var names = deps.map(function (d) {
+      return d.name;
+    });
+    (0, import_vitest.expect)(names).toContain("react");
+    (0, import_vitest.expect)(names).toContain("react-native");
+    (0, import_vitest.expect)(names).toContain("./global.css");
+    (0, import_vitest.expect)(names).toContain("./Button");
+    (0, import_vitest.expect)(names).toContain("./icons");
+    (0, import_vitest.expect)(names).toContain("./helper");
+    (0, import_vitest.expect)(names).toContain("./dynamic-module");
+    (0, import_vitest.expect)(names).not.toContain("./user-types");
+    (0, import_vitest.expect)(names).not.toContain("./theme-types");
+    var reactDep = deps.find(function (d) {
+      return d.name === "react";
+    });
+    (0, import_vitest.expect)(reactDep.data.isESMImportAtSource).toBe(true);
+    (0, import_vitest.expect)(reactDep.data.asyncType).toBeNull();
+    (0, import_vitest.expect)(reactDep.data.locs.length).toBeGreaterThan(0);
+    var loc = reactDep.data.locs[0];
+    (0, import_vitest.expect)(loc.start.line).toBeGreaterThan(0);
+    (0, import_vitest.expect)(loc.start.column).toBeGreaterThanOrEqual(0);
+    (0, import_vitest.expect)(loc.end.line).toBeGreaterThanOrEqual(loc.start.line);
+    (0, import_vitest.expect)(loc.end.column).toBeGreaterThanOrEqual(0);
+    var helperDep = deps.find(function (d) {
+      return d.name === "./helper";
+    });
+    (0, import_vitest.expect)(helperDep.data.isESMImportAtSource).toBe(false);
+    (0, import_vitest.expect)(helperDep.data.asyncType).toBeNull();
+    var dynamicDep = deps.find(function (d) {
+      return d.name === "./dynamic-module";
+    });
+    (0, import_vitest.expect)(dynamicDep.data.asyncType).toBe("async");
+  });
+  (0, import_vitest.it)("marks requires inside a try block optional", function () {
+    var code = `
+      let worklets
+      try {
+        worklets = require('react-native-worklets-core')
+      } catch {}
+      const always = require('./always-there')
+    `;
+    var off = (0, import_metroNativeWorker.extractDependencies)(code, "setup.js");
+    (0, import_vitest.expect)(off.find(function (d) {
+      return d.name === "react-native-worklets-core";
+    }).data.isOptional).toBeUndefined();
+    var on = (0, import_metroNativeWorker.extractDependencies)(code, "setup.js", {
+      allowOptionalDependencies: true
+    });
+    (0, import_vitest.expect)(on.find(function (d) {
+      return d.name === "react-native-worklets-core";
+    }).data.isOptional).toBe(true);
+    (0, import_vitest.expect)(on.find(function (d) {
+      return d.name === "./always-there";
+    }).data.isOptional).toBeUndefined();
+    var excluded = (0, import_metroNativeWorker.extractDependencies)(code, "setup.js", {
+      allowOptionalDependencies: {
+        exclude: ["react-native-worklets-core"]
+      }
+    });
+    (0, import_vitest.expect)(excluded.find(function (d) {
+      return d.name === "react-native-worklets-core";
+    }).data.isOptional).toBeUndefined();
+  });
+  (0, import_vitest.it)("wraps modules in Metro CommonJS format with and without moduleId", function () {
+    var code = "exports.val = 123;";
+    var wrappedWithoutId = (0, import_metroNativeWorker.wrapModule)(code);
+    (0, import_vitest.expect)(wrappedWithoutId).toContain("__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {");
+    (0, import_vitest.expect)(wrappedWithoutId).toContain("var require = _$$_REQUIRE;");
+    (0, import_vitest.expect)(wrappedWithoutId).toContain("exports.val = 123;");
+    (0, import_vitest.expect)(wrappedWithoutId.endsWith(");")).toBe(true);
+    var wrappedWithId = (0, import_metroNativeWorker.wrapModule)(code, {
+      moduleId: 99,
+      dependencyIds: [1, 2, 3]
+    });
+    (0, import_vitest.expect)(wrappedWithId).toContain(", 99, [1,2,3]);");
+  });
+  (0, import_vitest.it)("transforms TSX with React JSX, Hermes lowering, and ZERO Babel", async function () {
+    var result = await (0, import_metroNativeWorker.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();
+    (0, import_vitest.expect)(result.output).toHaveLength(1);
+    var output = result.output[0];
+    (0, import_vitest.expect)(output.type).toBe("js/module");
+    (0, import_vitest.expect)(output.data.lineCount).toBeGreaterThan(0);
+    (0, import_vitest.expect)(output.data.map.length).toBeGreaterThan(0);
+    var code = output.data.code;
+    (0, import_vitest.expect)(code).toContain("__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {");
+    (0, import_vitest.expect)(code).toContain("var require = _$$_REQUIRE;");
+    (0, import_vitest.expect)(code).not.toContain("<View");
+    (0, import_vitest.expect)(code).not.toContain("<Text");
+    (0, import_vitest.expect)(code).toContain("this.greeting = \"Hello from Native\"");
+    var depNames = result.dependencies.map(function (d) {
+      return d.name;
+    });
+    (0, import_vitest.expect)(depNames).toContain("react");
+    (0, import_vitest.expect)(depNames).toContain("react-native");
+    (0, import_vitest.expect)(depNames).toContain("./helper");
+    (0, import_vitest.expect)(depNames).toContain("react/jsx-dev-runtime");
+  });
+  (0, import_vitest.it)("lowers async generators, including the method shorthand Hermes also rejects", async function () {
+    var sources = {
+      "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)
+          }
+        }
+      `
+    };
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = Object.entries(sources)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var [filename, sourceCode] = _step.value;
+        var result = await (0, import_metroNativeWorker.transform)({}, "/project", filename, Buffer.from(sourceCode, "utf8"), {
+          dev: true,
+          platform: "ios",
+          type: "module"
+        });
+        assertZeroBabelCalls();
+        var code = result.output[0].data.code;
+        (0, import_vitest.expect)(code, filename).not.toMatch(/\basync\s+function\s*\*/);
+        (0, import_vitest.expect)(code, filename).not.toMatch(/\basync\s*\*\s*[\w$[]/);
+        (0, import_vitest.expect)(code, filename).not.toMatch(/\bfor\s+await\s*\(/);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+  });
+  (0, import_vitest.it)("handles JSON files without Babel", async function () {
+    var jsonSource = JSON.stringify({
+      name: "my-package",
+      version: "1.0.0"
+    });
+    var result = await (0, import_metroNativeWorker.transform)({}, "/project", "package.json", Buffer.from(jsonSource, "utf8"), {
+      dev: true,
+      platform: "ios",
+      type: "module"
+    });
+    assertZeroBabelCalls();
+    (0, import_vitest.expect)(result.dependencies).toEqual([]);
+    (0, import_vitest.expect)(result.output).toHaveLength(1);
+    (0, import_vitest.expect)(result.output[0].type).toBe("js/module");
+    (0, import_vitest.expect)(result.output[0].data.code).toContain("module.exports = {\"name\":\"my-package\",\"version\":\"1.0.0\"}");
+    (0, import_vitest.expect)(result.output[0].data.code).toContain("__d(function (global, require");
+  });
+  (0, import_vitest.it)("handles Asset files without Babel", async function () {
+    var result = await (0, import_metroNativeWorker.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();
+    (0, import_vitest.expect)(result.output[0].type).toBe("js/module/asset");
+    (0, import_vitest.expect)(result.output[0].data.code).toContain("registerAsset(");
+    (0, import_vitest.expect)(result.output[0].data.code).toContain("__d(function");
+    var depNames = result.dependencies.map(function (d) {
+      return d.name;
+    });
+    (0, import_vitest.expect)(depNames).toContain("react-native/Libraries/Image/AssetRegistry");
+  });
+  (0, import_vitest.it)("handles Flow files by stripping types without Babel", async function () {
+    var result = await (0, import_metroNativeWorker.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();
+    (0, import_vitest.expect)(result.output[0].data.code).not.toContain(": number");
+    (0, import_vitest.expect)(result.output[0].data.code).toContain("function add(a, b)");
+  });
+  (0, import_vitest.it)("generates a deterministic cache key without Babel", function () {
+    var key1 = (0, import_metroNativeWorker.getCacheKey)({
+      globalPrefix: "__one_",
+      minifierPath: "terser"
+    }, {
+      projectRoot: "/app"
+    });
+    var key2 = (0, import_metroNativeWorker.getCacheKey)({
+      globalPrefix: "__one_",
+      minifierPath: "terser"
+    }, {
+      projectRoot: "/app"
+    });
+    var key3 = (0, import_metroNativeWorker.getCacheKey)({
+      globalPrefix: "__other_"
+    }, {
+      projectRoot: "/app"
+    });
+    assertZeroBabelCalls();
+    (0, import_vitest.expect)(key1).toBe(key2);
+    (0, import_vitest.expect)(key1).not.toBe(key3);
+    (0, import_vitest.expect)(typeof key1 === "undefined" ? "undefined" : _type_of(key1)).toBe("string");
+    (0, import_vitest.expect)(key1.length).toBe(64);
+  });
+  (0, import_vitest.it)("correctly sets transformerPath in buildMetroConfigInputFromViteConfig when active", async function () {
+    var mockViteConfig = {
+      root: process.cwd()
+    };
+    delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
+    var configDefault = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
+    (0, import_vitest.expect)(configDefault.defaultConfig.transformerPath).toContain("metroNativeWorker");
+    (0, import_vitest.expect)(configDefault.defaultConfig.transformer.transformerPath).toBeUndefined();
+    var configOptOff = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
+      nativeTransforms: false
+    });
+    (0, import_vitest.expect)(configOptOff.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
+    process.env.ONE_METRO_NATIVE_TRANSFORMS = "0";
+    var configEnvOff = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
+    (0, import_vitest.expect)(configEnvOff.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
+    process.env.ONE_METRO_NATIVE_TRANSFORMS = "1";
+    var configEnvOn = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
+      nativeTransforms: false
+    });
+    (0, import_vitest.expect)(configEnvOn.defaultConfig.transformerPath).toContain("metroNativeWorker");
+    delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
+  });
+  (0, import_vitest.it)("transforms and executes a real 2-module Metro bundle through metro-runtime require polyfill", async function () {
+    var depSource = "exports.value = 42;";
+    var aSource = "const dep = require(\"./dep\"); module.exports = { doubled: dep.value * 2 };";
+    var depRes = await (0, import_metroNativeWorker.transform)({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
+      dev: false,
+      platform: "ios",
+      type: "module",
+      moduleId: 2,
+      dependencyIds: []
+    });
+    var aRes = await (0, import_metroNativeWorker.transform)({}, "/project", "a.js", Buffer.from(aSource, "utf8"), {
+      dev: false,
+      platform: "ios",
+      type: "module",
+      moduleId: 1,
+      dependencyIds: [2]
+    });
+    assertZeroBabelCalls();
+    (0, import_vitest.expect)(aRes.dependencies).toHaveLength(1);
+    (0, import_vitest.expect)(aRes.dependencies[0].name).toBe("./dep");
+    var aEmittedCode = aRes.output[0].data.code;
+    (0, import_vitest.expect)(aEmittedCode).toContain("require(_dependencyMap[0], \"./dep\")");
+    var polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
+    var polyfillCode = fs.readFileSync(polyfillPath, "utf8");
+    var 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);
+    var executedExports = vm.runInContext("global.__r(1)", contextObj);
+    (0, import_vitest.expect)(executedExports).toEqual({
+      doubled: 84
+    });
+  });
+  (0, import_vitest.it)("transforms and executes a 2-module Metro bundle with ESM imports in dev mode", async function () {
+    var depSource = "export const greeting = \"Hello Metro Native\";";
+    var aSource = "import { greeting } from \"./dep\"; export const message = greeting.toUpperCase();";
+    var depRes = await (0, import_metroNativeWorker.transform)({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
+      dev: true,
+      platform: "ios",
+      type: "module",
+      moduleId: 2,
+      dependencyIds: []
+    });
+    var aRes = await (0, import_metroNativeWorker.transform)({}, "/project", "a.js", Buffer.from(aSource, "utf8"), {
+      dev: true,
+      platform: "ios",
+      type: "module",
+      moduleId: 1,
+      dependencyIds: [2]
+    });
+    assertZeroBabelCalls();
+    var polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
+    var polyfillCode = fs.readFileSync(polyfillPath, "utf8");
+    var 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);
+    var executedExports = vm.runInContext("global.__r(1)", contextObj);
+    (0, import_vitest.expect)(executedExports.message).toBe("HELLO METRO NATIVE");
+  });
+  (0, import_vitest.it)("respects lexical scope shadowing for require calls (Astra probe)", async function () {
+    var res = await (0, import_metroNativeWorker.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();
+    (0, import_vitest.expect)(res.dependencies).toHaveLength(0);
+    var emitted = res.output[0].data.code;
+    (0, import_vitest.expect)(emitted).not.toContain("_dependencyMap[0]");
+    (0, import_vitest.expect)(emitted).toMatch(/require\d*\("\.\/local"\)/);
+    var polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
+    var polyfillCode = fs.readFileSync(polyfillPath, "utf8");
+    var contextObj = {
+      __DEV__: false,
+      __METRO_GLOBAL_PREFIX__: "",
+      console
+    };
+    contextObj.global = contextObj;
+    vm.createContext(contextObj);
+    vm.runInContext(polyfillCode, contextObj);
+    vm.runInContext(emitted, contextObj);
+    var result = vm.runInContext("global.__r(1)", contextObj);
+    (0, import_vitest.expect)(result).toBe("./local");
+  });
+  (0, import_vitest.it)("preserves distinct indexed identity for duplicate and mixed sync/async dependencies", async function () {
+    var res = await (0, import_metroNativeWorker.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();
+    var depNames = res.dependencies.map(function (d) {
+      return d.name;
+    });
+    (0, import_vitest.expect)(depNames).toContain("./dep");
+    var syncDep = res.dependencies.find(function (d) {
+      return d.name === "./dep" && d.data.asyncType === null;
+    });
+    var asyncDep = res.dependencies.find(function (d) {
+      return d.name === "./dep" && d.data.asyncType === "async";
+    });
+    (0, import_vitest.expect)(syncDep).toBeDefined();
+    (0, import_vitest.expect)(asyncDep).toBeDefined();
+    (0, import_vitest.expect)(syncDep.data.index).not.toEqual(asyncDep.data.index);
+    var emitted = res.output[0].data.code;
+    var syncIndex = syncDep.data.index;
+    (0, import_vitest.expect)(emitted).toContain(`require(_dependencyMap[${syncIndex}], "./dep")`);
+  });
+  (0, import_vitest.it)("conforms to Metro map ABI with raw mapping segment tuples and accurate symbolication", async function () {
+    var res = await (0, import_metroNativeWorker.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();
+    var map = res.output[0].data.map;
+    (0, import_vitest.expect)(Array.isArray(map)).toBe(true);
+    (0, import_vitest.expect)(map.length).toBeGreaterThan(0);
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var tuple = _step.value;
+        (0, import_vitest.expect)(Array.isArray(tuple)).toBe(true);
+        (0, import_vitest.expect)(_type_of(tuple[0])).toBe("number");
+        (0, import_vitest.expect)(_type_of(tuple[1])).toBe("number");
+        (0, import_vitest.expect)(tuple).not.toHaveProperty("version");
+        (0, import_vitest.expect)(tuple).not.toHaveProperty("mappings");
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+    var msm = await import("metro-source-map");
+    var fullMap = msm.fromRawMappings([{
+      code: res.output[0].data.code,
+      source: "math.ts",
+      map
+    }]).toMap();
+    var consumer = new msm.Consumer(fullMap);
+    var addLineIndex = res.output[0].data.code.split("\n").findIndex(function (l) {
+      return l.includes("function add");
+    });
+    (0, import_vitest.expect)(addLineIndex).toBeGreaterThan(0);
+    var pos = consumer.originalPositionFor({
+      line: addLineIndex + 1,
+      column: 16
+    });
+    (0, import_vitest.expect)(pos.line).toBe(2);
+  });
+  (0, import_vitest.it)("models JS hoisting in ScopeTracker for functions and vars (Astra probe)", async function () {
+    var res = await (0, import_metroNativeWorker.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();
+    (0, import_vitest.expect)(res.dependencies).toHaveLength(0);
+    var emitted = res.output[0].data.code;
+    (0, import_vitest.expect)(emitted).not.toContain("_dependencyMap[0]");
+    (0, import_vitest.expect)(emitted).toMatch(/require\d*\("\.\/local"\)/);
+    var polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
+    var polyfillCode = fs.readFileSync(polyfillPath, "utf8");
+    var contextObj = {
+      __DEV__: false,
+      __METRO_GLOBAL_PREFIX__: "",
+      console
+    };
+    contextObj.global = contextObj;
+    vm.createContext(contextObj);
+    vm.runInContext(polyfillCode, contextObj);
+    vm.runInContext(emitted, contextObj);
+    var result = vm.runInContext("global.__r(1)", contextObj);
+    (0, import_vitest.expect)(result).toBe("./local");
+  });
+  (0, import_vitest.it)("rewrites dynamic import to Metro asyncRequire and executes promise resolution in dev and release", async function () {
+    var depSource = "exports.message = \"hello dynamic\";";
+    var mainSource = "module.exports = () => import(\"./dep\");";
+    var depRes = await (0, import_metroNativeWorker.transform)({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
+      dev: true,
+      platform: "ios",
+      type: "module",
+      moduleId: 2,
+      dependencyIds: []
+    });
+    var mainRes = await (0, import_metroNativeWorker.transform)({}, "/project", "main.js", Buffer.from(mainSource, "utf8"), {
+      dev: true,
+      platform: "ios",
+      type: "module",
+      moduleId: 0,
+      dependencyIds: [2, 1]
+    });
+    assertZeroBabelCalls();
+    var depNames = mainRes.dependencies.map(function (d) {
+      return d.name;
+    });
+    (0, import_vitest.expect)(depNames).toContain("./dep");
+    (0, import_vitest.expect)(depNames).toContain("metro-runtime/src/modules/asyncRequire");
+    var dynDep = mainRes.dependencies.find(function (d) {
+      return d.name === "./dep";
+    });
+    (0, import_vitest.expect)(dynDep.data.asyncType).toBe("async");
+    var emittedMain = mainRes.output[0].data.code;
+    (0, import_vitest.expect)(emittedMain).not.toContain("import(\"./dep\")");
+    (0, import_vitest.expect)(emittedMain).toContain("require(_dependencyMap[1], \"metro-runtime/src/modules/asyncRequire\")(_dependencyMap[0], _dependencyMap.paths, \"./dep\")");
+    var polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
+    var polyfillCode = fs.readFileSync(polyfillPath, "utf8");
+    var asyncRequirePath = require.resolve("metro-runtime/src/modules/asyncRequire.js");
+    var asyncRequireSource = fs.readFileSync(asyncRequirePath, "utf8");
+    var wrappedAsyncRequire = (0, import_metroNativeWorker.wrapModule)(asyncRequireSource, {
+      moduleId: 1,
+      dependencyIds: []
+    });
+    for (var _i = 0, _iter = [true, false]; _i < _iter.length; _i++) {
+      var contextObj = {
+        __DEV__: _iter[_i],
+        __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);
+      var mainFn = vm.runInContext("global.__r(0)", contextObj);
+      (0, import_vitest.expect)(typeof mainFn === "undefined" ? "undefined" : _type_of(mainFn)).toBe("function");
+      var promise = mainFn();
+      (0, import_vitest.expect)(_instanceof(promise, Promise) || promise && typeof promise.then === "function").toBe(true);
+      var resolved = await promise;
+      (0, import_vitest.expect)(resolved.message).toBe("hello dynamic");
+      (0, import_vitest.expect)(resolved.default.message).toBe("hello dynamic");
+    }
+  });
+  (0, import_vitest.it)("preserves accurate sourcemap for tokens after rewritten require calls on the same line", async function () {
+    var sourceCode = "const a = require(\"./dep\"), b = 42;";
+    var resWrapped = await (0, import_metroNativeWorker.transform)({}, "/project", "app.js", Buffer.from(sourceCode, "utf8"), {
+      dev: false,
+      platform: "ios",
+      type: "module"
+    });
+    assertZeroBabelCalls();
+    var msm = await import("metro-source-map");
+    var fullMapWrapped = msm.fromRawMappings([{
+      code: resWrapped.output[0].data.code,
+      source: "app.js",
+      map: resWrapped.output[0].data.map
+    }]).toMap();
+    var consumerWrapped = new msm.Consumer(fullMapWrapped);
+    var linesWrapped = resWrapped.output[0].data.code.split("\n");
+    var lineIndexWrapped = linesWrapped.findIndex(function (l) {
+      return l.includes("b = 42");
+    });
+    (0, import_vitest.expect)(lineIndexWrapped).toBeGreaterThanOrEqual(0);
+    var generatedColWrapped = linesWrapped[lineIndexWrapped].indexOf("b = 42");
+    (0, import_vitest.expect)(generatedColWrapped).toBeGreaterThan(0);
+    var posWrapped = consumerWrapped.originalPositionFor({
+      line: lineIndexWrapped + 1,
+      column: generatedColWrapped
+    });
+    (0, import_vitest.expect)(posWrapped.line).toBe(1);
+    (0, import_vitest.expect)(posWrapped.column).toBe(28);
+    (0, import_vitest.expect)(sourceCode.slice(Number(posWrapped.column))).toContain("b = 42;");
+    var resUnwrapped = await (0, import_metroNativeWorker.transform)({
+      unstable_disableModuleWrapping: true
+    }, "/project", "app.js", Buffer.from(sourceCode, "utf8"), {
+      dev: false,
+      platform: "ios",
+      type: "module"
+    });
+    var fullMapUnwrapped = msm.fromRawMappings([{
+      code: resUnwrapped.output[0].data.code,
+      source: "app.js",
+      map: resUnwrapped.output[0].data.map
+    }]).toMap();
+    var consumerUnwrapped = new msm.Consumer(fullMapUnwrapped);
+    var linesUnwrapped = resUnwrapped.output[0].data.code.split("\n");
+    var lineIndexUnwrapped = linesUnwrapped.findIndex(function (l) {
+      return l.includes("b = 42");
+    });
+    (0, import_vitest.expect)(lineIndexUnwrapped).toBeGreaterThanOrEqual(0);
+    var generatedColUnwrapped = linesUnwrapped[lineIndexUnwrapped].indexOf("b = 42");
+    var posUnwrapped = consumerUnwrapped.originalPositionFor({
+      line: lineIndexUnwrapped + 1,
+      column: generatedColUnwrapped
+    });
+    (0, import_vitest.expect)(posUnwrapped.line).toBe(1);
+    (0, import_vitest.expect)(posUnwrapped.column).toBe(28);
+  });
+  (0, import_vitest.it)("routes a require.context whose directory is held in a variable through the dependency map", async function () {
+    var result = await (0, import_metroNativeWorker.transform)({}, "/project", "entry.js", Buffer.from(`
+      const routeRoot = './app'
+      export const ctx = require.context(routeRoot, true, /\\.tsx$/)
+    `, "utf8"), {
+      dev: true,
+      platform: "ios",
+      type: "module"
+    });
+    var contextDep = result.dependencies.find(function (d) {
+      return d.data.contextParams != null;
+    });
+    (0, import_vitest.expect)(contextDep === null || contextDep === void 0 ? void 0 : contextDep.name).toBe("./app");
+    var calls = [];
+    var ctx;
+    vm.runInNewContext(result.output[0].data.code, {
+      __d: function (factory) {
+        var module2 = {
+          exports: {}
+        };
+        var req = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+          calls.push(args);
+          return {
+            keys: function () {
+              return [];
+            }
+          };
+        };
+        req.context = function () {
+          throw new Error("fallbackRequireContext reached");
+        };
+        factory({}, req, function () {
+          return {};
+        }, function () {
+          return {};
+        }, module2, module2.exports, ["./app"]);
+        ctx = module2.exports.ctx;
+      }
+    });
+    (0, import_vitest.expect)(ctx).toBeDefined();
+    (0, import_vitest.expect)(calls[0][1]).toBe("./app");
+  });
+  (0, import_vitest.it)("gives loop bodies per-iteration bindings that survive a runtime without them", async function () {
+    var asHermesWouldSeeIt = (await (0, import_metroNativeWorker.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");
+    var collect;
+    vm.runInNewContext(asHermesWouldSeeIt, {
+      __d: function (factory) {
+        var module2 = {
+          exports: {}
+        };
+        factory({}, function () {
+          return {};
+        }, function () {
+          return {};
+        }, function () {
+          return {};
+        }, module2, module2.exports, []);
+        collect = module2.exports.collect;
+      }
+    });
+    (0, import_vitest.expect)(collect()).toEqual([0, 1, "a", "b", "x", "y"]);
+  });
+});
+(0, import_vitest.describe)("one native transform ports", function () {
+  (0, import_vitest.it)("inlines process.env.ONE_SERVER_URL so a native bundle can find its loaders", function () {
+    process.env.ONE_SERVER_URL = "https://example.test";
+    try {
+      var out = (0, import_metroNativeWorker.applyInlineEnvVars)("export const url = process.env.ONE_SERVER_URL;", "loader.ts", false);
+      (0, import_vitest.expect)(out).toBe("export const url = \"https://example.test\";");
+    } finally {
+      process.env.ONE_SERVER_URL = void 0;
+    }
+  });
+  (0, import_vitest.it)("leaves ONE_SERVER_URL alone when it is only a string", function () {
+    var src = "export const key = \"process.env.ONE_SERVER_URL\";";
+    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)(src, "a.ts", false)).toBe(src);
+  });
+  (0, import_vitest.it)("inlines import.meta.env reads, which oxc otherwise lowers to an empty object", function () {
+    var out = (0, import_metroNativeWorker.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"
+    });
+    (0, import_vitest.expect)(out).toContain("export const key = \"pk_live\";");
+    (0, import_vitest.expect)(out).toContain("export const target = \"native\";");
+    (0, import_vitest.expect)(out).toContain("export const missing = undefined;");
+    (0, import_vitest.expect)(out).toContain("\"VITE_POSTHOG_API_KEY\":\"pk_live\"");
+    (0, import_vitest.expect)(out).not.toContain("import.meta");
+  });
+  (0, import_vitest.it)("inlines process.env keys the vite env map defines", function () {
+    var out = (0, import_metroNativeWorker.applyInlineEnvVars)("export const t = process.env.TAMAGUI_TARGET; export const u = process.env.UNKNOWN_THING;", "env.ts", true, {
+      TAMAGUI_TARGET: "native"
+    });
+    (0, import_vitest.expect)(out).toContain("export const t = \"native\";");
+    (0, import_vitest.expect)(out).toContain("process.env.UNKNOWN_THING");
+  });
+  (0, import_vitest.it)("never rewrites an env read in an assignment target", function () {
+    var src = "process.env.VITE_ENVIRONMENT = \"ssr\";";
+    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)(src, "a.ts", true, {
+      VITE_ENVIRONMENT: "ios"
+    })).toBe(src);
+  });
+  (0, import_vitest.it)("folds branches the inlining made constant so metro never resolves dead imports", function () {
+    var out = (0, import_metroNativeWorker.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"
+    });
+    (0, import_vitest.expect)(out).not.toContain("server-only-thing");
+    (0, import_vitest.expect)(out).toContain("load(\"https://api.test\")");
+  });
+  (0, import_vitest.it)("folds a ternary and keeps a branch it cannot resolve", function () {
+    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)("const a = import.meta.env.DEV ? x : y;", "a.ts", true, {
+      DEV: false
+    })).toContain("const a = y;");
+    var dynamic = "const a = flag ? x : y;";
+    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)(dynamic, "a.ts", true, {
+      DEV: false
+    })).toBe(dynamic);
+  });
+  (0, import_vitest.it)("runs the user native transforms that stand in for their babel plugins", async function () {
+    var result = await (0, import_metroNativeWorker.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();
+    (0, import_vitest.expect)(result.output[0].data.code).toContain("\"ios-build\"");
+    (0, import_vitest.expect)(result.output[0].data.code).not.toContain("__EXAMPLE_BUILD_ID");
+    (0, import_vitest.expect)(result.output[0].data.code).toContain(JSON.stringify(path.join(import_meta.dirname, "ota.ts")));
+  });
+  (0, import_vitest.it)("refuses to build when a user babel plugin has no native port", function () {
+    var withPlugins = function (plugins) {
+      return {
+        customTransformOptions: {
+          vite: {
+            babelConfig: {
+              plugins
+            }
+          }
+        }
+      };
+    };
+    (0, import_vitest.expect)(function () {
+      return (0, import_metroNativeWorker.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/);
+    (0, import_vitest.expect)(function () {
+      return (0, import_metroNativeWorker.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();
+  });
+  (0, import_vitest.it)("turns a server-only import into a throw and drops native-only", function () {
+    var out = (0, import_metroNativeWorker.applyEnvironmentGuard)(`import 'native-only'
+import 'server-only'
+export const a = 1`, "route.ts");
+    (0, import_vitest.expect)(out).not.toContain("native-only");
+    (0, import_vitest.expect)(out).toContain("server-only cannot be imported in a native environment");
+    var parsed = (0, import_oxc_parser.parseSync)("route.ts", out, {
+      lang: "ts"
+    });
+    (0, import_vitest.expect)(parsed.errors).toEqual([]);
+    (0, import_vitest.expect)(parsed.program.body.map(function (n) {
+      return n.type;
+    })).toContain("ThrowStatement");
+  });
+  (0, import_vitest.it)("reads the router root off one's remove-server-code plugin entry", function () {
+    (0, import_vitest.expect)((0, import_metroNativeWorker.getRemoveServerCodeRouterRoot)({
+      customTransformOptions: {
+        vite: {
+          babelConfig: {
+            plugins: [["one/babel-plugin-remove-server-code", {
+              routerRoot: "src/app"
+            }]]
+          }
+        }
+      }
+    })).toBe("src/app");
+    (0, import_vitest.expect)((0, import_metroNativeWorker.getRemoveServerCodeRouterRoot)({
+      customTransformOptions: {}
+    })).toBe(void 0);
+  });
+});
+//# sourceMappingURL=metroNativeWorker.test.native.js.map