vxrn 1.26.0 → 1.26.1

package/dist/utils/createNativeDevEngine.test.native.js

@@ -1,14 +1,16 @@
-import { existsSync } from "fs";
+import { existsSync, realpathSync } from "fs";
 import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import { createContext, runInContext, runInNewContext } from "vm";
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import { rolldown } from "rolldown";
 import { dev } from "rolldown/experimental";
+import { normalizePath } from "vite";
 import { describe, expect, it, vi } from "vitest";
 import { getNativePrelude } from "../runtime/native-prelude.native.js";
 import { workletImportsPlugin } from "../plugins/workletImportsPlugin.native.js";
-import { buildNativeBundle, createNativeDevAssetRegistry, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.native.js";
+import { buildNativeBundle, createNativeDevAssetRegistry, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, postProcessNativeBundle, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.native.js";
 function _instanceof(left, right) {
   if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);else return left instanceof right;
 }
@@ -17,6 +19,108 @@ function _type_of(obj) {
 
   return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
+describe.each(["ios", "android"])("native plugin adapters on %s", function (platform) {
+  it.each(["dev", "build"])("binds configured plugins to the %s bundle", async function (mode) {
+    var root2 = await mkdtemp(join(tmpdir(), "vxrn-native-plugin-adapter-"));
+    await writeFile(join(root2, "entry.js"), `globalThis.nativePluginResult = [__GLOBAL_PLUGIN__, __DIRECT_PLUGIN__, 'plain-plugin']`);
+    var factories = ["global", "direct"].map(function (name) {
+      return vi.fn(function (context2) {
+        return {
+          name: `${name}-native`,
+          transform(code2, id) {
+            if (id.endsWith("/entry.js")) return code2.replace(`__${name.toUpperCase()}_PLUGIN__`, JSON.stringify({
+              name,
+              ...context2
+            }));
+          }
+        };
+      });
+    });
+    var plugins = factories.map(function (vxrnNative, index) {
+      return {
+        name: `adapter-${index}`,
+        api: {
+          vxrnNative
+        }
+      };
+    });
+    var previousPlugins = globalThis.__vxrnAddNativePlugins;
+    globalThis.__vxrnAddNativePlugins = [plugins[0]];
+    var configuredPlugins = [plugins[1], {
+      name: "plain-native-plugin",
+      transform(code2, id) {
+        if (id.endsWith("/__virtual-native-entry.tsx")) return `import './entry.js'`;
+        if (id.endsWith("/entry.js")) return code2.replace("plain-plugin", "plain");
+      }
+    }];
+    var native;
+    try {
+      var code;
+      if (mode === "dev") {
+        native = await createNativeDevEngine({
+          root: root2,
+          platform,
+          port: 0,
+          plugins: configuredPlugins
+        });
+        code = (await native.getBundle()).code;
+      } else code = (await buildNativeBundle({
+        root: root2,
+        platform,
+        entryFile: "entry.js",
+        plugins: configuredPlugins
+      })).code;
+      var context = {
+        console,
+        setTimeout,
+        clearTimeout,
+        __GLOBAL_PLUGIN__: "unadapted",
+        __DIRECT_PLUGIN__: "unadapted"
+      };
+      runInNewContext(code, context);
+      expect(Reflect.get(context, "nativePluginResult")).toEqual([{
+        name: "global",
+        root: root2,
+        platform,
+        dev: mode === "dev"
+      }, {
+        name: "direct",
+        root: root2,
+        platform,
+        dev: mode === "dev"
+      }, "plain"]);
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = factories[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var factory = _step.value;
+          expect(factory).toHaveBeenCalledExactlyOnceWith({
+            root: root2,
+            platform,
+            dev: mode === "dev"
+          });
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+        } finally {
+          if (_didIteratorError) throw _iteratorError;
+        }
+      }
+    } finally {
+      await (native === null || native === void 0 ? void 0 : native.close());
+      globalThis.__vxrnAddNativePlugins = previousPlugins;
+      await rm(root2, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
 var nativeTransformProbe = `
 export const transformProbe = () => {
   'worklet'
@@ -97,14 +201,14 @@ globalThis.result = (function(parentArgument) {
       return value === "closed";
     })).toHaveLength(1);
     var {
-      originalPositionFor,
-      TraceMap
+      originalPositionFor: originalPositionFor2,
+      TraceMap: TraceMap2
     } = await import("@jridgewell/trace-mapping");
     var lines = output.code.split("\n");
     var line = lines.findIndex(function (value) {
       return value.includes("after-await");
     });
-    var position = originalPositionFor(new TraceMap(output.map), {
+    var position = originalPositionFor2(new TraceMap2(output.map), {
       line: line + 1,
       column: lines[line].indexOf("events.push")
     });
@@ -126,8 +230,8 @@ describe.each(["shared", "rolldown", "metro"])("React Compiler worklets through
       default: MagicString
     } = await import("magic-string");
     var {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     var projectRoot = await createWorkletsProject(false);
     var sourceMaps = process.env.VXRN_ENABLE_SOURCE_MAP;
@@ -262,7 +366,7 @@ return ${pipeline === "metro" ? "module.exports.useProbe" : "useProbe"}`)(memo,
         return text.includes("function useProbe(");
       });
       expect(line).toBeGreaterThanOrEqual(0);
-      var position = originalPositionFor(new TraceMap(result.map), {
+      var position = originalPositionFor2(new TraceMap2(result.map), {
         line: line + 1,
         column: lines[line].indexOf("function")
       });
@@ -438,6 +542,7 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
           "pure-math": ["default", "reads"]
         })]
       });
+      expect(production.code).not.toContain("__esmMin");
       var productionRN = {
         console
       };
@@ -446,6 +551,23 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
       expect(reconstruct(productionRN.calculate)(10)).toBe(109);
       expect(reconstruct(productionRN.reads)()).toBe(3);
       expect(productionRN.reads()).toBe(1);
+      var unminifiedProduction = await buildNativeBundle({
+        root: root2,
+        platform: "android",
+        entryFile: "production.mjs",
+        minify: false,
+        plugins: [workletImportsPlugin({
+          "pure-math": ["default", "reads"]
+        })]
+      });
+      expect(unminifiedProduction.code).toContain("__esmMin");
+      var unminifiedRN = {
+        console
+      };
+      runInNewContext(unminifiedProduction.code, unminifiedRN);
+      expect(unminifiedRN.calculate(10)).toBe(109);
+      expect(reconstruct(unminifiedRN.calculate)(10)).toBe(109);
+      expect(reconstruct(unminifiedRN.reads)()).toBe(3);
       var sharedPlugin = workletImportsPlugin({
         "pure-math": ["default", "reads"]
       });
@@ -1148,8 +1270,8 @@ describe("native required transform failures", function () {
   });
   it("composes source maps across React Compiler, Fast Refresh, and module wrapper back to original source lines", async function () {
     var {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     var compiler = await import("@vxrn/compiler");
     compiler.configureVXRNCompilerPlugin({
@@ -1169,12 +1291,12 @@ export function Counter() {
       var result = await Reflect.apply(plugin.transform, void 0, [inputCode, id]);
       expect(result).toBeDefined();
       expect(result.map).toBeDefined();
-      var tracer = new TraceMap(result.map);
+      var tracer = new TraceMap2(result.map);
       var counterLineIndex = result.code.split("\n").findIndex(function (l) {
         return l.includes("function Counter");
       });
       expect(counterLineIndex).toBeGreaterThan(0);
-      var pos = originalPositionFor(tracer, {
+      var pos = originalPositionFor2(tracer, {
         line: counterLineIndex + 1,
         column: 16
       });
@@ -1188,8 +1310,8 @@ export function Counter() {
   });
   it("composes source maps accurately across mixed path (React Compiler + Babel + Fast Refresh + module wrapper)", async function () {
     var {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     var compiler = await import("@vxrn/compiler");
     var origEnv = process.env.VXRN_USE_BABEL_FOR_GENERATORS;
@@ -1216,14 +1338,14 @@ export async function* probe() { throw new Error("MARKER"); }
       expect(result).toBeDefined();
       expect(result.map).toBeDefined();
       expect(result.code.includes("_wrapAsyncGenerator") || result.code.includes("regeneratorRuntime")).toBe(true);
-      var tracer = new TraceMap(result.map);
+      var tracer = new TraceMap2(result.map);
       var lines = result.code.split("\n");
       var markerLineIndex = lines.findIndex(function (l) {
         return l.includes("MARKER");
       });
       expect(markerLineIndex).toBeGreaterThan(0);
       var markerCol = lines[markerLineIndex].indexOf("throw");
-      var pos = originalPositionFor(tracer, {
+      var pos = originalPositionFor2(tracer, {
         line: markerLineIndex + 1,
         column: markerCol
       });
@@ -1232,7 +1354,7 @@ export async function* probe() { throw new Error("MARKER"); }
       expect(pos.column).toBe(33);
       var compilerOut = await compiler.transformOxcReactCompiler(id, inputCode, "19", true);
       var remapping = (await import("@jridgewell/remapping")).default;
-      var badPos = originalPositionFor(new TraceMap(remapping([result.map, compilerOut.map], function () {
+      var badPos = originalPositionFor2(new TraceMap2(remapping([result.map, compilerOut.map], function () {
         return null;
       })), {
         line: markerLineIndex + 1,
@@ -1249,8 +1371,8 @@ export async function* probe() { throw new Error("MARKER"); }
   });
   it("transforms worklets via native Rust/Wasm SWC with zero Babel execution and accurate sourcemaps", async function () {
     var {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     var compiler = await import("@vxrn/compiler");
     var {
@@ -1282,12 +1404,12 @@ export function Box() {
       expect(result.code).toContain("__closure");
       expect(babelSpy).not.toHaveBeenCalled();
       expect(result.map).toBeDefined();
-      var tracer = new TraceMap(result.map);
+      var tracer = new TraceMap2(result.map);
       var boxLineIndex = result.code.split("\n").findIndex(function (l) {
         return l.includes("export function Box");
       });
       expect(boxLineIndex).toBeGreaterThan(0);
-      var pos = originalPositionFor(tracer, {
+      var pos = originalPositionFor2(tracer, {
         line: boxLineIndex + 1,
         column: 16
       });
@@ -1379,6 +1501,92 @@ export function Box() {
     }
   });
 });
+describe("native production minification", function () {
+  async function writeMinifyFixture() {
+    var root2 = await mkdtemp(join(tmpdir(), "vxrn-native-minify-"));
+    var dep = join(root2, "node_modules", "legacy-color");
+    await mkdir(dep, {
+      recursive: true
+    });
+    await writeFile(join(dep, "package.json"), JSON.stringify({
+      name: "legacy-color",
+      main: "index.js"
+    }));
+    await writeFile(join(dep, "index.js"), `function LegacyColor(value) { this.value = value }
+LegacyColor.prototype.describe = function () { return 'legacy:' + this.value }
+module.exports = LegacyColor`);
+    await writeFile(join(root2, "views.js"), `'use strict';
+import LegacyColor from 'legacy-color'
+import { level } from './entry.js'
+export const describeHeader = () => new LegacyColor(level()).describe()`);
+    await writeFile(join(root2, "entry.js"), `import { describeHeader } from './views.js'
+export const level = () => 'header'
+globalThis.minifyProbe = describeHeader()`);
+    return root2;
+  }
+  function runFixture(code) {
+    var context = {
+      console
+    };
+    runInNewContext(code, context);
+    return Reflect.get(context, "minifyProbe");
+  }
+  it("minifies when asked, leaves the bundle alone when not, and both behave the same", async function () {
+    var root2 = await writeMinifyFixture();
+    try {
+      var [plain, minified] = await Promise.all([false, true].map(function (minify) {
+        return buildNativeBundle({
+          root: root2,
+          platform: "ios",
+          entryFile: "entry.js",
+          minify
+        });
+      }));
+      expect(plain.code).toContain("__toESM");
+      expect(plain.code).toContain("describeHeader");
+      expect(plain.code.split("\n").length).toBeGreaterThan(40);
+      expect(minified.code).not.toContain("describeHeader");
+      expect(minified.code).not.toContain("//#region");
+      expect(minified.code.length).toBeLessThan(plain.code.length * .7);
+      expect(runFixture(minified.code)).toBe("legacy:header");
+      expect(runFixture(plain.code)).toBe("legacy:header");
+    } finally {
+      await rm(root2, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  it("defaults to react native's rule: minify a production bundle, never a dev one", async function () {
+    var root2 = await writeMinifyFixture();
+    try {
+      var [prod, devBundle, explicitOff] = await Promise.all([buildNativeBundle({
+        root: root2,
+        platform: "ios",
+        entryFile: "entry.js"
+      }), buildNativeBundle({
+        root: root2,
+        platform: "ios",
+        entryFile: "entry.js",
+        dev: true
+      }), buildNativeBundle({
+        root: root2,
+        platform: "ios",
+        entryFile: "entry.js",
+        minify: false
+      })]);
+      expect(prod.code).not.toContain("describeHeader");
+      expect(devBundle.code).toContain("describeHeader");
+      expect(explicitOff.code).toContain("describeHeader");
+      expect(prod.code.length).toBeLessThan(explicitOff.code.length);
+    } finally {
+      await rm(root2, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
 describe("native production assets", function () {
   it("registers scale siblings and keeps monorepo assets inside assetsDest", async function () {
     var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-assets-"));
@@ -1415,12 +1623,27 @@ globalThis.__nativeAssetProbe = [icon, back]
       expect((_registry_resolve = registry.resolve("/assets/assets/icon@2x.png", assetData.hash)) === null || _registry_resolve === void 0 ? void 0 : _registry_resolve.filePath).toBe(join(appAssets, "icon@2x.png"));
       expect(registry.resolve("/assets/assets/icon.png", "stale-content-hash")).toBeUndefined();
       expect(registry.resolve("/assets/../../package.json", assetData.hash)).toBeUndefined();
-      expect((await buildNativeBundle({
+      var result = await buildNativeBundle({
         root: appRoot,
         platform: "ios",
         entryFile: "entry.js",
         assetsDest
-      })).code).toMatch(/"scales":\s*\[\s*1,\s*2,\s*3\s*\]/);
+      });
+      var registered = [];
+      runInNewContext(result.code, {
+        console,
+        require: function (id) {
+          return id === "react-native/Libraries/Image/AssetRegistry" ? {
+            registerAsset: function (asset) {
+              registered.push(asset);
+              return asset;
+            }
+          } : {};
+        }
+      });
+      expect(registered.map(function (asset) {
+        return [asset.name, asset.scales];
+      })).toEqual([["icon", [1, 2, 3]], ["back", [1, 2]]]);
       for (var _i = 0, _iter = ["icon.png", "icon@2x.png", "icon@3x.png"]; _i < _iter.length; _i++) {
         var file = _iter[_i];
         expect(existsSync(join(assetsDest, "assets/assets", file))).toBe(true);
@@ -1643,4 +1866,77 @@ globalThis.__vxrnFlowProbe = new Flowy().measure({ value: 41 }) + 1
     }
   });
 });
+describe("native bundle source maps", function () {
+  var generatedPositionOf = function (code, marker) {
+    var _ref;
+    var _before_match;
+    var index = code.indexOf(marker);
+    expect(index).toBeGreaterThan(-1);
+    var before = code.slice(0, index);
+    var lastNewline = before.lastIndexOf("\n");
+    return {
+      line: ((_ref = (_before_match = before.match(/\n/g)) === null || _before_match === void 0 ? void 0 : _before_match.length) !== null && _ref !== void 0 ? _ref : 0) + 1,
+      column: index - lastNewline - 1
+    };
+  };
+  it("resolves a frame to the authored file and line across an app file and a package file", {
+    timeout: 6e4
+  }, async function () {
+    var testRoot = realpathSync(await mkdtemp(join(tmpdir(), "vxrn-native-sourcemap-")));
+    var packageRoot = join(testRoot, "node_modules/probe-package");
+    await mkdir(packageRoot, {
+      recursive: true
+    });
+    await writeFile(join(packageRoot, "package.json"), JSON.stringify({
+      name: "probe-package",
+      main: "index.js",
+      type: "module"
+    }));
+    await writeFile(join(packageRoot, "index.js"), [`function packageThrow() {`, `  throw new Error('__probe_package__')`, `}`, ``, `export default packageThrow`].join("\n"));
+    await writeFile(join(testRoot, "entry.js"), [`import packageThrow from 'probe-package'`, ``, `function appThrow() {`, `  throw new Error('__probe_app__')`, `}`, ``, `globalThis.__probe = [appThrow, packageThrow]`].join("\n"));
+    try {
+      var _app_source, _pkg_source;
+      var result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.js",
+        dev: true,
+        sourcemap: true
+      });
+      expect(result.map).toBeTruthy();
+      var traced = new TraceMap(JSON.parse(result.map));
+      var app = originalPositionFor(traced, generatedPositionOf(result.code, "__probe_app__"));
+      var pkg = originalPositionFor(traced, generatedPositionOf(result.code, "__probe_package__"));
+      expect((_app_source = app.source) === null || _app_source === void 0 ? void 0 : _app_source.endsWith("/entry.js")).toBe(true);
+      expect(app.line).toBe(4);
+      expect((_pkg_source = pkg.source) === null || _pkg_source === void 0 ? void 0 : _pkg_source.endsWith("/index.js")).toBe(true);
+      expect(pkg.line).toBe(2);
+      expect(app.source).toBe(normalizePath(join(testRoot, "entry.js")));
+      expect(pkg.source).toBe(normalizePath(join(packageRoot, "index.js")));
+    } finally {
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+describe("postProcessNativeBundle", function () {
+  var lines = function (code) {
+    return code.split("\n").length;
+  };
+  it("keeps the blank line above an export default", function () {
+    var input = ["var a = 1;", "", "export default a;", "var b = 2;", ""].join("\n");
+    var out = postProcessNativeBundle(input);
+    expect(lines(out)).toBe(lines(input));
+    expect(out.split("\n")[2]).toBe("a;");
+  });
+  it("keeps the lines of a multi-line export statement", function () {
+    var input = ["var a = 1;", "export {", "  a", "};", "var b = 2;", ""].join("\n");
+    var out = postProcessNativeBundle(input);
+    expect(lines(out)).toBe(lines(input));
+    expect(out).not.toContain("export {");
+    expect(out.split("\n")[4]).toBe("var b = 2;");
+  });
+});
 //# sourceMappingURL=createNativeDevEngine.test.native.js.map