vxrn 1.26.0 → 1.26.1

package/dist/utils/createNativeDevEngine.test.mjs

@@ -1,14 +1,95 @@
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createContext, runInContext, runInNewContext } from "node: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.mjs";
 import { workletImportsPlugin } from "../plugins/workletImportsPlugin.mjs";
-import { buildNativeBundle, createNativeDevAssetRegistry, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.mjs";
+import { buildNativeBundle, createNativeDevAssetRegistry, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, postProcessNativeBundle, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.mjs";
+describe.each(["ios", "android"])("native plugin adapters on %s", platform => {
+  it.each(["dev", "build"])("binds configured plugins to the %s bundle", async mode => {
+    const root2 = await mkdtemp(join(tmpdir(), "vxrn-native-plugin-adapter-"));
+    await writeFile(join(root2, "entry.js"), `globalThis.nativePluginResult = [__GLOBAL_PLUGIN__, __DIRECT_PLUGIN__, 'plain-plugin']`);
+    const factories = ["global", "direct"].map(name => vi.fn(context => ({
+      name: `${name}-native`,
+      transform(code, id) {
+        if (id.endsWith("/entry.js")) return code.replace(`__${name.toUpperCase()}_PLUGIN__`, JSON.stringify({
+          name,
+          ...context
+        }));
+      }
+    })));
+    const plugins = factories.map((vxrnNative, index) => ({
+      name: `adapter-${index}`,
+      api: {
+        vxrnNative
+      }
+    }));
+    const previousPlugins = globalThis.__vxrnAddNativePlugins;
+    globalThis.__vxrnAddNativePlugins = [plugins[0]];
+    const configuredPlugins = [plugins[1], {
+      name: "plain-native-plugin",
+      transform(code, id) {
+        if (id.endsWith("/__virtual-native-entry.tsx")) return `import './entry.js'`;
+        if (id.endsWith("/entry.js")) return code.replace("plain-plugin", "plain");
+      }
+    }];
+    let native;
+    try {
+      let 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;
+      const 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"]);
+      for (const factory of factories) expect(factory).toHaveBeenCalledExactlyOnceWith({
+        root: root2,
+        platform,
+        dev: mode === "dev"
+      });
+    } finally {
+      await native?.close();
+      globalThis.__vxrnAddNativePlugins = previousPlugins;
+      await rm(root2, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
 const nativeTransformProbe = `
 export const transformProbe = () => {
   'worklet'
@@ -85,12 +166,12 @@ globalThis.result = (function(parentArgument) {
     expect(result.events.filter(value => value === "finally")).toHaveLength(3);
     expect(result.events.filter(value => value === "closed")).toHaveLength(1);
     const {
-      originalPositionFor,
-      TraceMap
+      originalPositionFor: originalPositionFor2,
+      TraceMap: TraceMap2
     } = await import("@jridgewell/trace-mapping");
     const lines = output.code.split("\n");
     const line = lines.findIndex(value => value.includes("after-await"));
-    const position = originalPositionFor(new TraceMap(output.map), {
+    const position = originalPositionFor2(new TraceMap2(output.map), {
       line: line + 1,
       column: lines[line].indexOf("events.push")
     });
@@ -110,8 +191,8 @@ describe.each(["shared", "rolldown", "metro"])("React Compiler worklets through
       default: MagicString
     } = await import("magic-string");
     const {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     const projectRoot = await createWorkletsProject(false);
     const sourceMaps = process.env.VXRN_ENABLE_SOURCE_MAP;
@@ -210,7 +291,7 @@ return ${pipeline === "metro" ? "module.exports.useProbe" : "useProbe"}`)(memo,
       const lines = result.code.split("\n");
       const line = lines.findIndex(text => text.includes("function useProbe("));
       expect(line).toBeGreaterThanOrEqual(0);
-      const position = originalPositionFor(new TraceMap(result.map), {
+      const position = originalPositionFor2(new TraceMap2(result.map), {
         line: line + 1,
         column: lines[line].indexOf("function")
       });
@@ -378,6 +459,7 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
           "pure-math": ["default", "reads"]
         })]
       });
+      expect(production.code).not.toContain("__esmMin");
       const productionRN = {
         console
       };
@@ -386,6 +468,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);
+      const unminifiedProduction = await buildNativeBundle({
+        root: root2,
+        platform: "android",
+        entryFile: "production.mjs",
+        minify: false,
+        plugins: [workletImportsPlugin({
+          "pure-math": ["default", "reads"]
+        })]
+      });
+      expect(unminifiedProduction.code).toContain("__esmMin");
+      const 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);
       const sharedPlugin = workletImportsPlugin({
         "pure-math": ["default", "reads"]
       });
@@ -1047,8 +1146,8 @@ describe("native required transform failures", () => {
   });
   it("composes source maps across React Compiler, Fast Refresh, and module wrapper back to original source lines", async () => {
     const {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     const compiler = await import("@vxrn/compiler");
     compiler.configureVXRNCompilerPlugin({
@@ -1068,10 +1167,10 @@ export function Counter() {
       const result = await Reflect.apply(plugin.transform, void 0, [inputCode, id]);
       expect(result).toBeDefined();
       expect(result.map).toBeDefined();
-      const tracer = new TraceMap(result.map);
+      const tracer = new TraceMap2(result.map);
       const counterLineIndex = result.code.split("\n").findIndex(l => l.includes("function Counter"));
       expect(counterLineIndex).toBeGreaterThan(0);
-      const pos = originalPositionFor(tracer, {
+      const pos = originalPositionFor2(tracer, {
         line: counterLineIndex + 1,
         column: 16
       });
@@ -1085,8 +1184,8 @@ export function Counter() {
   });
   it("composes source maps accurately across mixed path (React Compiler + Babel + Fast Refresh + module wrapper)", async () => {
     const {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     const compiler = await import("@vxrn/compiler");
     const origEnv = process.env.VXRN_USE_BABEL_FOR_GENERATORS;
@@ -1113,12 +1212,12 @@ 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);
-      const tracer = new TraceMap(result.map);
+      const tracer = new TraceMap2(result.map);
       const lines = result.code.split("\n");
       const markerLineIndex = lines.findIndex(l => l.includes("MARKER"));
       expect(markerLineIndex).toBeGreaterThan(0);
       const markerCol = lines[markerLineIndex].indexOf("throw");
-      const pos = originalPositionFor(tracer, {
+      const pos = originalPositionFor2(tracer, {
         line: markerLineIndex + 1,
         column: markerCol
       });
@@ -1127,7 +1226,7 @@ export async function* probe() { throw new Error("MARKER"); }
       expect(pos.column).toBe(33);
       const compilerOut = await compiler.transformOxcReactCompiler(id, inputCode, "19", true);
       const remapping = (await import("@jridgewell/remapping")).default;
-      const badPos = originalPositionFor(new TraceMap(remapping([result.map, compilerOut.map], () => null)), {
+      const badPos = originalPositionFor2(new TraceMap2(remapping([result.map, compilerOut.map], () => null)), {
         line: markerLineIndex + 1,
         column: markerCol
       });
@@ -1142,8 +1241,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 () => {
     const {
-      TraceMap,
-      originalPositionFor
+      TraceMap: TraceMap2,
+      originalPositionFor: originalPositionFor2
     } = await import("@jridgewell/trace-mapping");
     const compiler = await import("@vxrn/compiler");
     const {
@@ -1175,10 +1274,10 @@ export function Box() {
       expect(result.code).toContain("__closure");
       expect(babelSpy).not.toHaveBeenCalled();
       expect(result.map).toBeDefined();
-      const tracer = new TraceMap(result.map);
+      const tracer = new TraceMap2(result.map);
       const boxLineIndex = result.code.split("\n").findIndex(l => l.includes("export function Box"));
       expect(boxLineIndex).toBeGreaterThan(0);
-      const pos = originalPositionFor(tracer, {
+      const pos = originalPositionFor2(tracer, {
         line: boxLineIndex + 1,
         column: 16
       });
@@ -1270,6 +1369,90 @@ export function Box() {
     }
   });
 });
+describe("native production minification", () => {
+  async function writeMinifyFixture() {
+    const root2 = await mkdtemp(join(tmpdir(), "vxrn-native-minify-"));
+    const 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) {
+    const 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 () => {
+    const root2 = await writeMinifyFixture();
+    try {
+      const [plain, minified] = await Promise.all([false, true].map(minify => 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 () => {
+    const root2 = await writeMinifyFixture();
+    try {
+      const [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", () => {
   it("registers scale siblings and keeps monorepo assets inside assetsDest", async () => {
     const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-assets-"));
@@ -1303,12 +1486,23 @@ globalThis.__nativeAssetProbe = [icon, back]
       expect(registry.resolve("/assets/assets/icon@2x.png", assetData.hash)?.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({
+      const result = await buildNativeBundle({
         root: appRoot,
         platform: "ios",
         entryFile: "entry.js",
         assetsDest
-      })).code).toMatch(/"scales":\s*\[\s*1,\s*2,\s*3\s*\]/);
+      });
+      const registered = [];
+      runInNewContext(result.code, {
+        console,
+        require: id => id === "react-native/Libraries/Image/AssetRegistry" ? {
+          registerAsset: asset => {
+            registered.push(asset);
+            return asset;
+          }
+        } : {}
+      });
+      expect(registered.map(asset => [asset.name, asset.scales])).toEqual([["icon", [1, 2, 3]], ["back", [1, 2]]]);
       for (const file of ["icon.png", "icon@2x.png", "icon@3x.png"]) expect(existsSync(join(assetsDest, "assets/assets", file))).toBe(true);
       for (const file of ["back.png", "back@2x.png"]) expect(existsSync(join(assetsDest, "assets/_/_/node_modules/example/assets", file))).toBe(true);
       expect(existsSync(join(testRoot, "node_modules/example/assets/back.png"))).toBe(false);
@@ -1523,4 +1717,72 @@ globalThis.__vxrnFlowProbe = new Flowy().measure({ value: 41 }) + 1
     }
   });
 });
+describe("native bundle source maps", () => {
+  const generatedPositionOf = (code, marker) => {
+    const index = code.indexOf(marker);
+    expect(index).toBeGreaterThan(-1);
+    const before = code.slice(0, index);
+    const lastNewline = before.lastIndexOf("\n");
+    return {
+      line: (before.match(/\n/g)?.length ?? 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 () => {
+    const testRoot = realpathSync(await mkdtemp(join(tmpdir(), "vxrn-native-sourcemap-")));
+    const 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 {
+      const result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.js",
+        dev: true,
+        sourcemap: true
+      });
+      expect(result.map).toBeTruthy();
+      const traced = new TraceMap(JSON.parse(result.map));
+      const app = originalPositionFor(traced, generatedPositionOf(result.code, "__probe_app__"));
+      const pkg = originalPositionFor(traced, generatedPositionOf(result.code, "__probe_package__"));
+      expect(app.source?.endsWith("/entry.js")).toBe(true);
+      expect(app.line).toBe(4);
+      expect(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", () => {
+  const lines = code => code.split("\n").length;
+  it("keeps the blank line above an export default", () => {
+    const input = ["var a = 1;", "", "export default a;", "var b = 2;", ""].join("\n");
+    const 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", () => {
+    const input = ["var a = 1;", "export {", "  a", "};", "var b = 2;", ""].join("\n");
+    const 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.mjs.map