@vxrn/compiler 1.25.13 → 1.25.16-1788753284749

package/dist/cjs/transformHermesLoops.test.cjs

@@ -0,0 +1,220 @@
+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("node:vm"), 1);
+var import_transformHermesLoops = require("./transformHermesLoops.cjs");
+function runAsHermes(code) {
+  const asHermesWouldSeeIt = code.replace(/\b(?:let|const)\b/g, "var");
+  const sandbox = {
+    result: void 0,
+    console
+  };
+  vm.runInNewContext(asHermesWouldSeeIt, sandbox);
+  return sandbox.result;
+}
+function run(source) {
+  const out = (0, import_transformHermesLoops.transformHermesLoops)(source, "test.js");
+  return runAsHermes(out ? out.code : source);
+}
+(0, import_vitest.describe)("transformHermesLoops", () => {
+  (0, import_vitest.it)("gives a C-style loop a per-iteration binding", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (let i = 0; i < 3; i++) fns.push(() => i)
+        result = fns.map((f) => f())
+      `)).toEqual([0, 1, 2]);
+  });
+  (0, import_vitest.it)("gives for-of and for-in per-iteration bindings", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (const label of ['a', 'b']) fns.push(() => label)
+        for (const key in { x: 1, y: 2 }) fns.push(() => key)
+        result = fns.map((f) => f())
+      `)).toEqual(["a", "b", "x", "y"]);
+  });
+  (0, import_vitest.it)("preserves break", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (let i = 0; i < 10; i++) {
+          if (i === 3) break
+          fns.push(() => i)
+        }
+        result = fns.map((f) => f())
+      `)).toEqual([0, 1, 2]);
+  });
+  (0, import_vitest.it)("preserves continue", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (let i = 0; i < 5; i++) {
+          if (i % 2 === 0) continue
+          fns.push(() => i)
+        }
+        result = fns.map((f) => f())
+      `)).toEqual([1, 3]);
+  });
+  (0, import_vitest.it)("preserves return out of the enclosing function", () => {
+    (0, import_vitest.expect)(run(`
+        function find() {
+          for (const n of [1, 2, 3]) {
+            const get = () => n
+            if (n === 2) return get()
+          }
+          return 'none'
+        }
+        result = find()
+      `)).toBe(2);
+  });
+  (0, import_vitest.it)("preserves a bare return", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        function go() {
+          for (let i = 0; i < 5; i++) {
+            if (i === 2) return
+            fns.push(() => i)
+          }
+        }
+        go()
+        result = fns.map((f) => f())
+      `)).toEqual([0, 1]);
+  });
+  (0, import_vitest.it)("leaves break and continue belonging to a nested loop alone", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (let i = 0; i < 2; i++) {
+          for (var j = 0; j < 5; j++) {
+            if (j > 0) break
+          }
+          fns.push(() => i)
+        }
+        result = fns.map((f) => f())
+      `)).toEqual([0, 1]);
+  });
+  (0, import_vitest.it)("handles nested capturing loops", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (let i = 0; i < 2; i++) {
+          for (let j = 0; j < 2; j++) {
+            fns.push(() => i + ':' + j)
+          }
+        }
+        result = fns.map((f) => f())
+      `)).toEqual(["0:0", "0:1", "1:0", "1:1"]);
+  });
+  (0, import_vitest.it)("handles await in the loop body", async () => {
+    const out = (0, import_transformHermesLoops.transformHermesLoops)(`
+        var fns = []
+        async function go() {
+          for (const n of [1, 2]) {
+            await Promise.resolve()
+            fns.push(() => n)
+          }
+          return fns.map((f) => f())
+        }
+        result = go()
+      `, "test.js");
+    (0, import_vitest.expect)(out).not.toBeNull();
+    await (0, import_vitest.expect)(runAsHermes(out.code)).resolves.toEqual([1, 2]);
+  });
+  (0, import_vitest.it)("destructures a for-of binding per iteration", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (const { id } of [{ id: 'a' }, { id: 'b' }]) fns.push(() => id)
+        result = fns.map((f) => f())
+      `)).toEqual(["a", "b"]);
+  });
+  (0, import_vitest.it)("rewrites the esbuild interop helper that broke every multi-export module", () => {
+    (0, import_vitest.expect)(run(`
+        var __defProp = Object.defineProperty
+        var __getOwnPropNames = Object.getOwnPropertyNames
+        var from = { a: 1, b: 2 }
+        var to = {}
+        for (let key of __getOwnPropNames(from)) {
+          __defProp(to, key, { get: () => from[key], enumerable: true })
+        }
+        result = [to.a, to.b]
+      `)).toEqual([1, 2]);
+  });
+  (0, import_vitest.it)("leaves loops that never capture their binding untouched", () => {
+    (0, import_vitest.expect)((0, import_transformHermesLoops.transformHermesLoops)("for (let i = 0; i < 3; i++) sum += i", "test.js")).toBeNull();
+  });
+  (0, import_vitest.it)("gives a binding declared in the loop body a per-iteration copy", () => {
+    (0, import_vitest.expect)(run(`
+        var names = ['createAnimatedNode', 'addListener', 'removeListener']
+        var wrappers = {}
+        for (var ii = 0; ii < names.length; ii++) {
+          const methodName = names[ii]
+          wrappers[methodName] = () => methodName
+        }
+        result = names.map((n) => wrappers[n]())
+      `)).toEqual(["createAnimatedNode", "addListener", "removeListener"]);
+  });
+  (0, import_vitest.it)("gives a binding declared in a nested block of the loop body a per-iteration copy", () => {
+    (0, import_vitest.expect)(run(`
+        var fns = []
+        for (var i = 0; i < 3; i++) {
+          if (i >= 0) {
+            const doubled = i * 2
+            fns.push(() => doubled)
+          }
+        }
+        result = fns.map((f) => f())
+      `)).toEqual([0, 2, 4]);
+  });
+  (0, import_vitest.it)("keeps `this` and `arguments` meaning what they meant outside the loop", () => {
+    (0, import_vitest.expect)(run(`
+        class PropsFilter {
+          constructor() { this._map = { a: 'A', b: 'B' } }
+          filter(props) {
+            var out = []
+            for (const key in props) {
+              const label = key
+              out.push(() => this._map[label] + arguments.length)
+            }
+            return out
+          }
+        }
+        result = new PropsFilter().filter({ a: 1, b: 2 }).map((f) => f())
+      `)).toEqual(["A1", "B1"]);
+  });
+  (0, import_vitest.it)("leaves a loop with no lexical binding untouched", () => {
+    (0, import_vitest.expect)((0, import_transformHermesLoops.transformHermesLoops)("for (var i = 0; i < 3; i++) fns.push(() => i)", "test.js")).toBeNull();
+  });
+  (0, import_vitest.it)("leaves the head declaration alone so it cannot collide with a sibling", () => {
+    const out = (0, import_transformHermesLoops.transformHermesLoops)(`function build(gestures) {
+         var handlers = []
+         for (const gesture of gestures) { handlers.push(() => gesture) }
+         const gesture = gestures[0]
+         return gesture
+       }`, "Pressable.js");
+    (0, import_vitest.expect)(() => new vm.Script(out.code)).not.toThrow();
+  });
+  (0, import_vitest.it)("rewrites a loop in a .js file that still contains jsx", () => {
+    const out = (0, import_transformHermesLoops.transformHermesLoops)("for (const c of items) rows.push(() => <Row key={c} />)", "Rows.js");
+    (0, import_vitest.expect)(out?.code).toContain("_hermesLoop0");
+  });
+  (0, import_vitest.it)("does not rewrite a loop that reassigns its own binding", () => {
+    (0, import_vitest.expect)((0, import_transformHermesLoops.transformHermesLoops)("for (let i = 0; i < 3; i++) { i += 1; fns.push(() => i) }", "test.js")).toBeNull();
+  });
+});

package/dist/cjs/transformSWC.cjs

@@ -1,6 +1,8 @@
+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 __export = (target, all) => {
   for (var name in all) __defProp(target, name, {
@@ -17,18 +19,28 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: true
 }), mod);
 var transformSWC_exports = {};
 __export(transformSWC_exports, {
+  shouldSourceMap: () => shouldSourceMap,
+  transformOxc: () => transformOxc,
+  transformOxcStripJSX: () => transformOxcStripJSX,
   transformSWC: () => transformSWC,
   transformSWCStripJSX: () => transformSWCStripJSX
 });
 module.exports = __toCommonJS(transformSWC_exports);
 var import_node_path = require("node:path");
-var import_core = require("@swc/core");
-var import_ts_deepmerge = require("ts-deepmerge");
 var import_vite = require("vite");
 var import_configure = require("./configure.cjs");
 var import_constants = require("./constants.cjs");
@@ -41,100 +53,53 @@ async function transformSWC(id, code, options, swcOptions) {
   if (id === import_constants.runtimePublicPath) {
     return;
   }
-  const parser = getParser(id, options.forceJSX);
-  if (!parser) {
+  const lang = getLang(id, options.forceJSX);
+  if (!lang) {
     return;
   }
   const refresh = options.environment !== "ssr" && !options.production && !options.noHMR && !options.forceJSX && !id.includes("node_modules");
-  const reactConfig = {
-    refresh,
-    development: !options.forceJSX && !options.production,
-    runtime: "automatic",
-    importSource: "react",
-    ...(import_configure.configuration.enableNativewind && !id.includes("node_modules") ? {
-      importSource: "nativewind"
-      // pragma: 'createInteropElement',
-      // pragmaFrag: '_InteropFragment',
-      // swc doesnt actually change the import right
-      // runtime: 'classic',
-    } : {})
-  };
-  const transformOptions = (() => {
-    if (options.environment === "client" || options.environment === "ssr") {
-      return {
-        sourceMaps: shouldSourceMap(),
-        jsc: {
-          target: "es2020",
-          parser,
-          transform: {
-            useDefineForClassFields: true,
-            react: reactConfig
-          }
-        }
-      };
+  const importSource = import_configure.configuration.enableNativewind && !id.includes("node_modules") ? "nativewind" : "react";
+  const shouldEs5Transform = options.es5 || !process.env.VXRN_USE_BABEL_FOR_GENERATORS && import_constants.asyncGeneratorRegex.test(code);
+  const target = shouldEs5Transform ? "es2015" : "es2020";
+  const sourceMaps = swcOptions?.sourceMaps !== void 0 ? Boolean(swcOptions.sourceMaps) : shouldSourceMap();
+  const oxcOptions = {
+    lang,
+    target,
+    assumptions: {
+      setPublicClassFields: true,
+      ...(swcOptions?.assumptions || {})
+    },
+    sourcemap: sourceMaps,
+    jsx: {
+      runtime: "automatic",
+      development: !options.forceJSX && !options.production,
+      refresh: Boolean(refresh),
+      importSource
     }
-    const shouldEs5Transform = options.es5 || !process.env.VXRN_USE_BABEL_FOR_GENERATORS && import_constants.asyncGeneratorRegex.test(code);
-    const opts = shouldEs5Transform ? {
-      jsc: {
-        parser,
-        target: "es5",
-        transform: {
-          useDefineForClassFields: true,
-          react: reactConfig
-        }
-      }
-    } : {
-      ...(!options.forceJSX && {
-        env: SWC_ENV
-      }),
-      jsc: {
-        ...(options.forceJSX && {
-          target: "esnext"
-        }),
-        parser,
-        transform: {
-          useDefineForClassFields: true,
-          react: reactConfig
-        }
-      }
-    };
-    return {
-      sourceMaps: shouldSourceMap(),
-      module: {
-        importInterop: "none",
-        type: "nodenext"
-      },
-      ...(options.mode === "serve-cjs" && {
-        module: {
-          importInterop: "none",
-          type: "commonjs",
-          strict: true
-        }
-      }),
-      ...opts
-    };
-  })();
-  const finalOptions = (0, import_ts_deepmerge.merge)({
-    filename: id,
-    swcrc: false,
-    configFile: false,
-    ...transformOptions
-  }, swcOptions || {});
-  const result = await (async () => {
+  };
+  const {
+    transformSync
+  } = await import("oxc-transform");
+  const result = (() => {
     try {
-      (0, import_constants.debug)?.(`transformSWC ${id} using options:
-${JSON.stringify(finalOptions, null, 2)}`);
-      return await (0, import_core.transform)(code, finalOptions);
-    } catch (e) {
-      const message = e.message;
-      const fileStartIndex = message.indexOf("\u256D\u2500[");
-      if (fileStartIndex !== -1) {
-        const match = message.slice(fileStartIndex).match(/:(\d+):(\d+)]/);
-        if (match) {
-          e.line = match[1];
-          e.column = match[2];
+      (0, import_constants.debug)?.(`transformSWC (oxc) ${id} using options:
+${JSON.stringify(oxcOptions, null, 2)}`);
+      const res = transformSync(id, code, oxcOptions);
+      if (res.errors?.length) {
+        const err = res.errors[0];
+        const error = new Error(err.message + (err.codeframe ? `
+${err.codeframe}` : ""));
+        if (err.labels?.[0]) {
+          error.start = err.labels[0].start;
+          error.end = err.labels[0].end;
         }
+        throw error;
       }
+      return {
+        code: res.code,
+        map: res.map
+      };
+    } catch (e) {
       throw e;
     }
   })();
@@ -145,7 +110,7 @@ ${result.code}`;
     }
   }
   const hasRefreshRuntime = refresh && refreshContentRE.test(result.code);
-  if (options.fixNonTypeSpecificImports || id.includes("node_modules") && parser.syntax === "typescript") {
+  if (options.fixNonTypeSpecificImports || id.includes("node_modules") && (lang === "ts" || lang === "tsx")) {
     const typeExportsMatch = code.match(/^\s*export\s+type\s+([^\s]+)/gi);
     if (typeExportsMatch) {
       for (const typeExport of Array.from(typeExportsMatch)) {
@@ -168,6 +133,7 @@ ${fakeExport}
   }
   return result;
 }
+const transformOxc = transformSWC;
 function wrapSourceInRefreshRuntime(id, result, options, hasRefreshRuntime) {
   if (options.environment === "ssr") {
     return result;
@@ -178,7 +144,9 @@ function wrapSourceInRefreshRuntime(id, result, options, hasRefreshRuntime) {
   return wrapSourceInRefreshRuntimeNative(id, result, options, hasRefreshRuntime);
 }
 function wrapSourceInRefreshRuntimeWeb(id, result, hasRefreshRuntime) {
-  const sourceMap = result.map ? JSON.parse(result.map) : void 0;
+  const sourceMap = result.map ? typeof result.map === "string" ? JSON.parse(result.map) : {
+    ...result.map
+  } : void 0;
   if (sourceMap) {
     sourceMap.mappings = ";;" + sourceMap.mappings;
   }
@@ -235,7 +203,9 @@ globalThis.$RefreshReg$ = (type, id) => RefreshRuntime.register(type, "${id}" +
 globalThis.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
 module.url = '${id}'
 module.hot = createHotContext(module.url)`;
-    const sourceMap = result.map ? JSON.parse(result.map) : void 0;
+    const sourceMap = result.map ? typeof result.map === "string" ? JSON.parse(result.map) : {
+      ...result.map
+    } : void 0;
     if (sourceMap) {
       const prefixLen = prefixCode.split("\n").length + 1;
       sourceMap.mappings = new Array(prefixLen).fill(";").join("") + sourceMap.mappings;
@@ -258,61 +228,56 @@ ${postfixCode}
   result.code += postfixCode;
   return result;
 }
-const SWC_ENV = {
-  targets: {
-    node: "4"
-  },
-  // debug: true,
-  include: [],
-  // this breaks the uniswap app for any file with a ...spread
-  exclude: ["transform-spread", "transform-destructuring", "transform-object-rest-spread",
-  // `transform-async-to-generator` is relying on `transform-destructuring`.
-  // If we exclude `transform-destructuring` but not `transform-async-to-generator`, the SWC binary will panic
-  // with error: `called `Option::unwrap()` on a `None` value`.
-  // See: https://github.com/swc-project/swc/blob/v1.7.14/crates/swc_ecma_compat_es2015/src/generator.rs#L703-L705
-  "transform-async-to-generator", "transform-regenerator"
-  // Similar to above
-  ]
-};
 const refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/;
 function shouldSourceMap() {
   return process.env.VXRN_ENABLE_SOURCE_MAP === "1";
 }
-function getParser(id, forceJSX = false) {
+function getLang(id, forceJSX = false) {
   if (id.endsWith("one-entry-native")) {
-    return import_constants.parsers[".tsx"];
+    return "tsx";
   }
   const extension = (0, import_node_path.extname)(id);
-  let parser = !extension ? import_constants.parsers[".js"] : import_constants.parsers[extension];
-  if (extension === ".js" || extension === ".mjs") {
-    if (forceJSX) {
-      parser = import_constants.parsers[".jsx"];
-    }
-    if (id.includes("expo-modules-core")) {
-      parser = import_constants.parsers[".jsx"];
+  if (extension === ".tsx") return "tsx";
+  if (extension === ".ts") return "ts";
+  if (extension === ".jsx" || extension === ".mdx") return "jsx";
+  if (extension === ".js" || extension === ".mjs" || extension === ".cjs") {
+    if (forceJSX || id.includes("expo-modules-core")) {
+      return "jsx";
     }
+    return "js";
+  }
+  if (!extension) {
+    return forceJSX ? "jsx" : "js";
   }
-  return parser;
+  return void 0;
 }
 const transformSWCStripJSX = async (id, code) => {
-  const parser = getParser(id);
-  if (!parser) return;
-  return await (0, import_core.transform)(code, {
-    filename: id,
-    swcrc: false,
-    configFile: false,
-    sourceMaps: shouldSourceMap(),
-    jsc: {
-      target: "es2019",
-      parser,
-      transform: {
-        useDefineForClassFields: true,
-        react: {
-          development: true,
-          runtime: "automatic",
-          refresh: false
-        }
-      }
+  const lang = getLang(id);
+  if (!lang) return;
+  const {
+    transformSync
+  } = await import("oxc-transform");
+  const res = transformSync(id, code, {
+    lang,
+    target: "es2020",
+    assumptions: {
+      setPublicClassFields: true
+    },
+    sourcemap: shouldSourceMap(),
+    jsx: {
+      runtime: "automatic",
+      development: true,
+      refresh: false
     }
   });
-};
+  if (res.errors?.length) {
+    const err = res.errors[0];
+    throw new Error(err.message + (err.codeframe ? `
+${err.codeframe}` : ""));
+  }
+  return {
+    code: res.code,
+    map: res.map
+  };
+};
+const transformOxcStripJSX = transformSWCStripJSX;

package/dist/cjs/transformSWC.test.cjs

@@ -0,0 +1,74 @@
+var import_vitest = require("vitest");
+var import_transformSWC = require("./transformSWC.cjs");
+(0, import_vitest.describe)("transformSWC / transformOxc with oxc-transform for Hermes lowering", () => {
+  (0, import_vitest.it)("lowers class fields, private fields, and static blocks with Hermes target and assumptions", async () => {
+    const input = `
+class Sample {
+  #secret = 42
+  publicField = 100
+  static {
+    Sample.initialized = true
+  }
+  getSecret() {
+    return this.#secret
+  }
+}
+`;
+    const res = await (0, import_transformSWC.transformSWC)("Sample.ts", input, {
+      environment: "ios",
+      mode: "build"
+    });
+    (0, import_vitest.expect)(res).toBeDefined();
+    (0, import_vitest.expect)(res.code).not.toContain("#secret");
+    (0, import_vitest.expect)(res.code).not.toMatch(/^\s*publicField\s*=/m);
+    (0, import_vitest.expect)(res.code).not.toContain("static {");
+    (0, import_vitest.expect)(res.code).toContain("this.publicField = 100");
+  });
+  (0, import_vitest.it)("lowers JSX to react automatic runtime calls", async () => {
+    const input = `
+export function MyComponent() {
+  return <div className="test"><span>Hello</span></div>
+}
+`;
+    const res = await (0, import_transformSWC.transformSWC)("MyComponent.tsx", input, {
+      environment: "client",
+      mode: "build"
+    });
+    (0, import_vitest.expect)(res).toBeDefined();
+    (0, import_vitest.expect)(res.code).not.toContain("<div");
+    (0, import_vitest.expect)(res.code).not.toContain("<span>");
+    (0, import_vitest.expect)(res.code).toContain("_jsx");
+  });
+  (0, import_vitest.it)("respects sourcemaps option", async () => {
+    const input = `
+class Sample {
+  val = 1
+}
+`;
+    const resWithoutMap = await (0, import_transformSWC.transformSWC)("Sample.ts", input, {
+      environment: "ios",
+      mode: "build"
+    }, {
+      sourceMaps: false
+    });
+    (0, import_vitest.expect)(resWithoutMap?.map).toBeUndefined();
+    const resWithMap = await (0, import_transformSWC.transformSWC)("Sample.ts", input, {
+      environment: "ios",
+      mode: "build"
+    }, {
+      sourceMaps: true
+    });
+    (0, import_vitest.expect)(resWithMap?.map).toBeDefined();
+    (0, import_vitest.expect)(resWithMap?.map.mappings).toBeDefined();
+  });
+  (0, import_vitest.it)("provides transformOxc alias", () => {
+    (0, import_vitest.expect)(import_transformSWC.transformOxc).toBe(import_transformSWC.transformSWC);
+  });
+  (0, import_vitest.it)("strips JSX using transformSWCStripJSX", async () => {
+    const input = `export const el = <div>Hello</div>`;
+    const res = await (0, import_transformSWC.transformSWCStripJSX)("el.tsx", input);
+    (0, import_vitest.expect)(res).toBeDefined();
+    (0, import_vitest.expect)(res.code).not.toContain("<div>");
+    (0, import_vitest.expect)(res.code).toContain("_jsx");
+  });
+});