@vxrn/compiler 1.25.16 → 1.26.0

package/dist/cjs/transformSWC.test.cjs

@@ -0,0 +1,117 @@
+var import_vitest = require("vitest");
+var import_node_vm = require("node:vm");
+var import_rolldown = require("rolldown");
+var import_transformSWC = require("./transformSWC.cjs");
+(0, import_vitest.describe)("transformSWC / transformOxc with oxc-transform for Hermes lowering", () => {
+  (0, import_vitest.it)("preserves unbraced for-await bodies and early returns", async () => {
+    const result = await (0, import_transformSWC.transformSWC)("AsyncIterable.js", `
+        async function collect(it) {
+          const values = []
+          for await (const value of it) values.push(value)
+          return values
+        }
+        async function first(it) {
+          for await (const value of it) return value
+          return null
+        }
+        globalThis.result = Promise.all([collect([11, 22]), first([11, 22])])
+      `, {
+      environment: "ios",
+      mode: "build",
+      production: true
+    });
+    (0, import_vitest.expect)(result).toBeDefined();
+    const bundle = await (0, import_rolldown.rolldown)({
+      input: "virtual:async-iterable.js",
+      plugins: [{
+        name: "async-iterable-fixture",
+        resolveId(id) {
+          if (id === "virtual:async-iterable.js") return id;
+        },
+        load(id) {
+          if (id === "virtual:async-iterable.js") return result.code;
+        }
+      }]
+    });
+    try {
+      const output = await bundle.generate({
+        format: "iife"
+      });
+      const context = {};
+      (0, import_node_vm.runInNewContext)(output.output[0].code, context);
+      await (0, import_vitest.expect)(context.result).resolves.toEqual([[11, 22], 11]);
+    } finally {
+      await bundle.close();
+    }
+  });
+  (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");
+  });
+  import_vitest.it.each(["MyComponent.tsx", "MyComponent.js", "MyComponent.mjs", "MyComponent.cjs"])("lowers JSX in %s to react automatic runtime calls", async filename => {
+    const input = `
+export function MyComponent() {
+  return <div className="test"><span>Hello</span></div>
+}
+`;
+    const res = await (0, import_transformSWC.transformSWC)(filename, 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");
+  });
+});

package/dist/cjs/transformWorklets.cjs

@@ -0,0 +1,123 @@
+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, {
+    get: all[name],
+    enumerable: true
+  });
+};
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var transformWorklets_exports = {};
+__export(transformWorklets_exports, {
+  REANIMATED_AUTOWORKLETIZATION_KEYWORDS: () => REANIMATED_AUTOWORKLETIZATION_KEYWORDS,
+  getWorkletsVersion: () => getWorkletsVersion,
+  prepareWorkletsForReactCompiler: () => import_transform2.prepareWorkletsForReactCompiler,
+  shouldTransformWorklets: () => shouldTransformWorklets,
+  transformWorklets: () => transformWorklets
+});
+module.exports = __toCommonJS(transformWorklets_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_module = require("node:module");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_configure = require("./configure.cjs");
+var import_autoworklet = require("./worklets/autoworklet.cjs");
+var import_transform = require("./worklets/transform.cjs");
+var import_transform2 = require("./worklets/transform.cjs");
+const import_meta = {};
+const REANIMATED_AUTOWORKLETIZATION_KEYWORDS = ["worklet", "useAnimatedGestureHandler", "useAnimatedScrollHandler", "useFrameCallback", "useAnimatedStyle", "useAnimatedProps", "createAnimatedPropAdapter", "useDerivedValue", "useAnimatedReaction", "useWorkletCallback", "withTiming", "withSpring", "withDecay", "withRepeat", "runOnUI", "executeOnUIRuntimeSync"];
+const REANIMATED_REGEX = new RegExp([... /* @__PURE__ */new Set([...REANIMATED_AUTOWORKLETIZATION_KEYWORDS, ...Object.keys(import_autoworklet.AUTOWORKLET_FUNCTION_ARGS),
+// gesture callbacks are only workletized on a `Gesture.<Kind>()` chain,
+// but this file gate has to be permissive or a file whose only worklets
+// are gesture callbacks never reaches the transform at all.
+...import_autoworklet.GESTURE_BUILDER_METHODS, "withCallback"])].map(name => `\\b${name}\\b`).join("|"));
+const REANIMATED_IGNORED_PATHS = ["react-native-prebuilt", "node_modules/.vxrn/react-native", "node_modules/react/", "node_modules/react-dom/", "node_modules/react-native/",
+// react-native's own scoped packages are flow, and the worklets transform
+// runs before flow stripping in the vite pipeline. they never hold app
+// worklets, exactly like node_modules/react-native/ above.
+"node_modules/@react-native/", "node_modules/react-native-web/"];
+const REANIMATED_IGNORED_PATHS_REGEX = new RegExp(REANIMATED_IGNORED_PATHS.join("|"));
+function shouldTransformWorklets({
+  id,
+  code
+}) {
+  if (!(0, import_configure.isNativeWorkletsEnabled)() || !import_configure.configuration.enableReanimated) {
+    return false;
+  }
+  const normalizedId = id.replace(/\\/g, "/");
+  if (REANIMATED_IGNORED_PATHS_REGEX.test(normalizedId)) {
+    return false;
+  }
+  return REANIMATED_REGEX.test(code);
+}
+function getWorkletsVersion(projectRoot, filename) {
+  if (projectRoot) {
+    try {
+      const req = (0, import_node_module.createRequire)(import_node_path.default.resolve(projectRoot, "package.json"));
+      try {
+        const ver = req("react-native-worklets/package.json")?.version;
+        if (ver) return ver;
+      } catch {}
+      try {
+        const ver = req("react-native-reanimated/package.json")?.version;
+        if (ver) return ver;
+      } catch {}
+    } catch {}
+    throw new Error(`[@vxrn/compiler] Unable to resolve "react-native-worklets" or "react-native-reanimated" version from project root "${projectRoot}". Please ensure react-native-worklets is installed in your project.`);
+  }
+  if (filename && !filename.startsWith("\0") && import_node_fs.default.existsSync(filename)) {
+    try {
+      const req = (0, import_node_module.createRequire)(filename);
+      try {
+        const ver = req("react-native-worklets/package.json")?.version;
+        if (ver) return ver;
+      } catch {}
+      try {
+        const ver = req("react-native-reanimated/package.json")?.version;
+        if (ver) return ver;
+      } catch {}
+    } catch {}
+  }
+  const fallbacks = [() => (0, import_node_module.createRequire)(import_node_path.default.resolve(process.cwd(), "package.json")), () => (0, import_node_module.createRequire)(import_meta.url)];
+  for (const getReq of fallbacks) {
+    try {
+      const req = getReq();
+      try {
+        const ver = req("react-native-worklets/package.json")?.version;
+        if (ver) return ver;
+      } catch {}
+      try {
+        const ver = req("react-native-reanimated/package.json")?.version;
+        if (ver) return ver;
+      } catch {}
+    } catch {}
+  }
+  const target = filename || process.cwd();
+  throw new Error(`[@vxrn/compiler] Unable to resolve "react-native-worklets" or "react-native-reanimated" version from "${target}". Please ensure react-native-worklets is installed in your project.`);
+}
+async function transformWorklets(id, code, sourceMaps = false, options) {
+  return (0, import_transform.executeWorkletTransform)(id, code, sourceMaps, options, getWorkletsVersion);
+}