@vxrn/compiler 1.25.13 → 1.25.16-1788753284749

package/dist/cjs/reactNativeViewConfig.cjs

@@ -0,0 +1,489 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var reactNativeViewConfig_exports = {};
+__export(reactNativeViewConfig_exports, {
+  generateViewConfig: () => generateViewConfig,
+  getLibraryName: () => getLibraryName,
+  parseSpec: () => parseSpec,
+  renderViewConfigModule: () => renderViewConfigModule
+});
+module.exports = __toCommonJS(reactNativeViewConfig_exports);
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+var import_oxc_parser = require("oxc-parser");
+const import_meta = {};
+const SELF_URL = typeof __filename !== "undefined" ? __filename : import_meta.url;
+const COLOR_ATTRIBUTE = "require('react-native/Libraries/Components/View/ReactNativeStyleAttributes').colorAttribute";
+const COLOR_ARRAY_ATTRIBUTE = "{\n      process: (req => 'default' in req ? req.default : req)(require('react-native/Libraries/StyleSheet/processColorArray'))\n    }";
+const IMAGE_ATTRIBUTE = "{\n      process: (req => 'default' in req ? req.default : req)(require('react-native/Libraries/Image/resolveAssetSource'))\n    }";
+const POINT_ATTRIBUTE = "{\n      diff: (req => 'default' in req ? req.default : req)(require('react-native/Libraries/Utilities/differ/pointsDiffer'))\n    }";
+const EDGE_INSETS_ATTRIBUTE = "{\n      diff: (req => 'default' in req ? req.default : req)(require('react-native/Libraries/Utilities/differ/insetsDiffer'))\n    }";
+const IMPORT_REGISTRY = "const NativeComponentRegistry = require('react-native/Libraries/NativeComponent/NativeComponentRegistry');";
+const IMPORT_IGNORE = "const {ConditionallyIgnoredEventHandlers} = require('react-native/Libraries/NativeComponent/ViewConfigIgnore');";
+const IMPORT_DISPATCH = 'const {dispatchCommand} = require("react-native/Libraries/ReactNative/RendererProxy");';
+const IMPORT_UIMANAGER = 'const {UIManager} = require("react-native-web")';
+let hermesParser = void 0;
+function getHermesParser(projectRoot) {
+  if (hermesParser === void 0) {
+    try {
+      const req = projectRoot ? (0, import_node_module.createRequire)((0, import_node_path.join)(projectRoot, "package.json")) : (0, import_node_module.createRequire)(SELF_URL);
+      hermesParser = req("hermes-parser");
+    } catch {
+      try {
+        hermesParser = (0, import_node_module.createRequire)(SELF_URL)("hermes-parser");
+      } catch {
+        hermesParser = null;
+      }
+    }
+  }
+  return hermesParser;
+}
+function readType(node) {
+  if (!node) return {
+    name: "",
+    args: []
+  };
+  switch (node.type) {
+    // flow
+    case "NullableTypeAnnotation":
+    case "TypeAnnotation":
+      return readType(node.typeAnnotation);
+    case "GenericTypeAnnotation":
+      return {
+        name: readTypeName(node.id),
+        args: (node.typeParameters?.params ?? []).map(readType)
+      };
+    case "ObjectTypeAnnotation":
+      return {
+        name: "__object",
+        args: []
+      };
+    case "StringTypeAnnotation":
+      return {
+        name: "string",
+        args: []
+      };
+    case "BooleanTypeAnnotation":
+      return {
+        name: "boolean",
+        args: []
+      };
+    case "NumberTypeAnnotation":
+      return {
+        name: "number",
+        args: []
+      };
+    case "UnionTypeAnnotation":
+      return readUnion(node);
+    case "FunctionTypeAnnotation":
+      return {
+        name: "__function",
+        args: []
+      };
+    // typescript
+    case "TSTypeAnnotation":
+      return readType(node.typeAnnotation);
+    case "TSTypeReference":
+      return {
+        name: readTypeName(node.typeName),
+        args: (node.typeArguments ?? node.typeParameters)?.params?.map(readType) ?? []
+      };
+    case "TSTypeLiteral":
+      return {
+        name: "__object",
+        args: []
+      };
+    case "TSStringKeyword":
+      return {
+        name: "string",
+        args: []
+      };
+    case "TSBooleanKeyword":
+      return {
+        name: "boolean",
+        args: []
+      };
+    case "TSNumberKeyword":
+      return {
+        name: "number",
+        args: []
+      };
+    case "TSUnionType":
+      return readUnion(node);
+    case "TSFunctionType":
+      return {
+        name: "__function",
+        args: []
+      };
+    case "TSArrayType":
+      return {
+        name: "Array",
+        args: [readType(node.elementType)]
+      };
+  }
+  return {
+    name: "__unknown",
+    args: []
+  };
+}
+const NULLISH_TYPES = /* @__PURE__ */new Set(["TSUndefinedKeyword", "TSNullKeyword", "TSVoidKeyword", "NullLiteralTypeAnnotation", "VoidTypeAnnotation"]);
+function readUnion(node) {
+  const real = (node.types ?? []).filter(t => !NULLISH_TYPES.has(t.type));
+  if (real.length === 1) return readType(real[0]);
+  return {
+    name: "__union",
+    args: []
+  };
+}
+function readTypeName(id) {
+  if (!id) return "";
+  if (id.type === "Identifier") return id.name;
+  if (id.type === "QualifiedTypeIdentifier") return readTypeName(id.id);
+  if (id.type === "TSQualifiedName") return readTypeName(id.right);
+  return "";
+}
+const READONLY_ARRAYS = /* @__PURE__ */new Set(["ReadonlyArray", "$ReadOnlyArray", "Array"]);
+const TRANSPARENT = /* @__PURE__ */new Set(["WithDefault", "UnsafeMixed", "Readonly", "$ReadOnly"]);
+function unwrap(type) {
+  let cur = type;
+  while (TRANSPARENT.has(cur.name) && cur.args.length > 0) {
+    cur = cur.args[0];
+  }
+  return cur;
+}
+function attributeValue(type) {
+  const t = unwrap(type);
+  switch (t.name) {
+    case "ColorValue":
+    case "ProcessedColorValue":
+      return COLOR_ATTRIBUTE;
+    case "ImageSource":
+      return IMAGE_ATTRIBUTE;
+    case "PointValue":
+      return POINT_ATTRIBUTE;
+    case "EdgeInsetsValue":
+      return EDGE_INSETS_ATTRIBUTE;
+  }
+  if (READONLY_ARRAYS.has(t.name) && t.args.length === 1) {
+    const el = unwrap(t.args[0]);
+    if (el.name === "ColorValue" || el.name === "ProcessedColorValue") {
+      return COLOR_ARRAY_ATTRIBUTE;
+    }
+  }
+  return "true";
+}
+function eventOf(name, type) {
+  const t = unwrap(type);
+  if (t.name !== "DirectEventHandler" && t.name !== "BubblingEventHandler") return null;
+  const override = t.args[1]?.name;
+  return {
+    name,
+    bubbling: t.name === "BubblingEventHandler",
+    topName: normalizeInputEventName(override && override !== "__unknown" ? override : name)
+  };
+}
+function normalizeInputEventName(name) {
+  if (name.startsWith("on")) return name.replace(/^on/, "top");
+  if (!name.startsWith("top")) return `top${name[0].toUpperCase()}${name.slice(1)}`;
+  return name;
+}
+function collectDeclarations(body) {
+  const out = /* @__PURE__ */new Map();
+  for (const raw of body) {
+    const node = raw?.type === "ExportNamedDeclaration" ? raw.declaration : raw;
+    if (!node) continue;
+    switch (node.type) {
+      case "TSTypeAliasDeclaration":
+      case "TypeAlias":
+      case "TSInterfaceDeclaration":
+      case "InterfaceDeclaration":
+        if (node.id?.name) out.set(node.id.name, node);
+        break;
+    }
+  }
+  return out;
+}
+function flattenMembers(typeName, decls, seen = /* @__PURE__ */new Set()) {
+  if (typeName === "ViewProps" || seen.has(typeName)) return [];
+  seen.add(typeName);
+  const decl = decls.get(typeName);
+  if (!decl) return [];
+  const out = [];
+  const heritage = decl.extends ?? decl.heritage ?? [];
+  for (const h of heritage) {
+    const name = readTypeName(h.id ?? h.expression ?? h.typeName);
+    if (name) out.push(...flattenMembers(name, decls, seen));
+  }
+  const bodyNode = decl.body ??
+  // interface
+  decl.right ??
+  // type alias
+  decl.typeAnnotation;
+  out.push(...readObjectMembers(bodyNode, decls, seen));
+  return out;
+}
+function readObjectMembers(node, decls, seen) {
+  if (!node) return [];
+  if (node.type === "TSTypeReference" || node.type === "GenericTypeAnnotation") {
+    const name = readTypeName(node.typeName ?? node.id);
+    const args = (node.typeArguments ?? node.typeParameters)?.params ?? [];
+    if (TRANSPARENT.has(name) && args.length) {
+      return readObjectMembers(args[0], decls, seen);
+    }
+    return flattenMembers(name, decls, seen);
+  }
+  if (node.type === "TSIntersectionType" || node.type === "IntersectionTypeAnnotation") {
+    const out2 = [];
+    for (const t of node.types ?? []) out2.push(...readObjectMembers(t, decls, seen));
+    return out2;
+  }
+  const members = node.members ?? node.body ?? node.properties ?? [];
+  const out = [];
+  for (const m of members) {
+    switch (m.type) {
+      case "TSPropertySignature":
+      case "ObjectTypeProperty":
+        {
+          const name = m.key?.name ?? m.key?.value;
+          if (!name) break;
+          out.push({
+            name,
+            type: readType(m.typeAnnotation ?? m.value)
+          });
+          break;
+        }
+      // flow's `...OtherProps` inside an object type
+      case "ObjectTypeSpreadProperty":
+        {
+          const name = readTypeName(m.argument?.id ?? m.argument);
+          if (name) out.push(...flattenMembers(name, decls, seen));
+          break;
+        }
+    }
+  }
+  return out;
+}
+function findComponentCall(body) {
+  for (const node of body) {
+    if (node.type !== "ExportDefaultDeclaration") continue;
+    let expr = node.declaration;
+    while (expr) {
+      if (expr.type === "CallExpression") break;
+      expr = expr.expression ?? (expr.type === "SequenceExpression" ? expr.expressions[expr.expressions.length - 1] : null);
+    }
+    if (expr?.type === "CallExpression" && expr.callee?.name === "codegenNativeComponent") {
+      return expr;
+    }
+  }
+  return null;
+}
+function findCommandsCall(body) {
+  for (const raw of body) {
+    const node = raw?.type === "ExportNamedDeclaration" ? raw.declaration : raw;
+    const decl = node?.declarations?.[0];
+    let init = decl?.init;
+    while (init && init.type !== "CallExpression") init = init.expression;
+    if (init?.type === "CallExpression" && init.callee?.name === "codegenNativeCommands") {
+      return init;
+    }
+  }
+  return null;
+}
+function readStringOption(objectExpression, key) {
+  for (const p of objectExpression?.properties ?? []) {
+    if ((p.key?.name ?? p.key?.value) === key && typeof p.value?.value === "string") {
+      return p.value.value;
+    }
+  }
+  return null;
+}
+function readCommands(call, decls) {
+  const typeName = readTypeName((call.typeArguments ?? call.typeParameters)?.params?.[0]?.typeName ?? (call.typeArguments ?? call.typeParameters)?.params?.[0]?.id);
+  const supported = [];
+  for (const p of call.arguments?.[0]?.properties ?? []) {
+    if ((p.key?.name ?? p.key?.value) !== "supportedCommands") continue;
+    for (const el of p.value?.elements ?? []) {
+      if (typeof el?.value === "string") supported.push(el.value);
+    }
+  }
+  if (!supported.length) return [];
+  const decl = decls.get(typeName);
+  const byName = /* @__PURE__ */new Map();
+  const commandMembers = decl?.body?.body ?? decl?.body?.members ?? decl?.body?.properties ?? [];
+  for (const m of commandMembers) {
+    const name = m.key?.name ?? m.key?.value;
+    if (!name) continue;
+    const fn = m.typeAnnotation?.typeAnnotation ?? m.value ?? m.typeAnnotation;
+    const params = (fn?.params ?? fn?.parameters ?? []).slice(1);
+    byName.set(name, params.map((p, i) => p.name?.name ?? p.name ?? `arg${i}`));
+  }
+  return supported.map(name => ({
+    name,
+    params: byName.get(name) ?? []
+  }));
+}
+function indent(text, spaces) {
+  const pad = " ".repeat(spaces);
+  return text.split("\n").map((line, i) => i === 0 || line === "" ? line : pad + line).join("\n");
+}
+function printViewConfig(componentName, attributes, events) {
+  const lines = [`  uiViewClassName: ${JSON.stringify(componentName)}`];
+  const bubbling = events.filter(e => e.bubbling);
+  if (bubbling.length) {
+    lines.push(`  bubblingEventTypes: {
+${bubbling.map(e => `    ${e.topName}: {
+      phasedRegistrationNames: {
+        captured: ${JSON.stringify(`${e.name}Capture`)},
+        bubbled: ${JSON.stringify(e.name)}
+      }
+    }`).join(",\n")}
+  }`);
+  }
+  const direct = events.filter(e => !e.bubbling);
+  if (direct.length) {
+    lines.push(`  directEventTypes: {
+${direct.map(e => `    ${e.topName}: {
+      registrationName: ${JSON.stringify(e.name)}
+    }`).join(",\n")}
+  }`);
+  }
+  const attrLines = attributes.map(a => `    ${a.name}: ${indent(a.value, 4)}`);
+  if (events.length) {
+    attrLines.push(`    ...ConditionallyIgnoredEventHandlers({
+${events.map(e => `      ${e.name}: true`).join(",\n")}
+    })`);
+  }
+  lines.push(attrLines.length ? `  validAttributes: {
+${attrLines.join(",\n")}
+  }` : "  validAttributes: {}");
+  return `{
+${lines.join(",\n")}
+}`;
+}
+function printCommands(commands) {
+  return `export const Commands = {
+${commands.map(c => `  ${c.name}(ref${c.params.map(p => `, ${p}`).join("")}) {
+    dispatchCommand(ref, ${JSON.stringify(c.name)}, [${c.params.join(", ")}]);
+  }`).join(",\n")}
+};`;
+}
+const FILE_HEADER = `/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @flow
+ *
+ * @generated by codegen project: GenerateViewConfigJs.js
+ */
+
+'use strict';
+`;
+function parseSpec(code, filename, projectRoot) {
+  const isTS = /\.[cm]?tsx?$/.test(filename);
+  if (isTS) {
+    const result = (0, import_oxc_parser.parseSync)(filename, code, {
+      lang: filename.endsWith("x") ? "tsx" : "ts"
+    });
+    if (result.errors?.length) return null;
+    return result.program;
+  }
+  const hermes = getHermesParser(projectRoot);
+  if (!hermes) return null;
+  try {
+    return hermes.parse(code, {
+      babel: false,
+      flow: "all",
+      sourceFilename: filename
+    });
+  } catch {
+    return null;
+  }
+}
+function generateViewConfig(program) {
+  const body = program?.body;
+  if (!body) return null;
+  const call = findComponentCall(body);
+  if (!call) return null;
+  const componentNameArg = call.arguments?.[0];
+  if (typeof componentNameArg?.value !== "string") return null;
+  const componentName = componentNameArg.value;
+  const options = call.arguments?.[1];
+  const paperComponentName = readStringOption(options, "paperComponentName");
+  const paperComponentNameDeprecated = readStringOption(options, "paperComponentNameDeprecated");
+  const propsTypeName = readTypeName((call.typeArguments ?? call.typeParameters)?.params?.[0]?.typeName ?? (call.typeArguments ?? call.typeParameters)?.params?.[0]?.id);
+  if (!propsTypeName) return null;
+  const decls = collectDeclarations(body);
+  const members = flattenMembers(propsTypeName, decls);
+  const attributes = [];
+  const events = [];
+  for (const m of members) {
+    const event = eventOf(m.name, m.type);
+    if (event) {
+      events.push(event);
+      continue;
+    }
+    attributes.push({
+      name: m.name,
+      value: attributeValue(m.type)
+    });
+  }
+  const commandsCall = findCommandsCall(body);
+  const commands = commandsCall ? readCommands(commandsCall, decls) : [];
+  const imports = /* @__PURE__ */new Set([IMPORT_REGISTRY]);
+  if (events.length) imports.add(IMPORT_IGNORE);
+  if (commands.length) imports.add(IMPORT_DISPATCH);
+  if (paperComponentNameDeprecated) imports.add(IMPORT_UIMANAGER);
+  const nativeName = paperComponentName ?? componentName;
+  const parts = [`let nativeComponentName = '${nativeName}';`];
+  if (paperComponentNameDeprecated) {
+    parts.push(`if (UIManager.hasViewManagerConfig('${componentName}')) {
+  nativeComponentName = '${componentName}';
+} else if (UIManager.hasViewManagerConfig('${paperComponentNameDeprecated}')) {
+  nativeComponentName = '${paperComponentNameDeprecated}';
+} else {
+  throw new Error('Failed to find native component for either "${componentName}" or "${paperComponentNameDeprecated}"');
+}`);
+  }
+  parts.push(`export const __INTERNAL_VIEW_CONFIG = ${printViewConfig(nativeName, attributes, events)};`);
+  parts.push("export default NativeComponentRegistry.get(nativeComponentName, () => __INTERNAL_VIEW_CONFIG);");
+  if (commands.length) parts.push(printCommands(commands));
+  return {
+    imports: [...imports].sort(),
+    body: parts.join("\n")
+  };
+}
+function renderViewConfigModule(result) {
+  return `
+${FILE_HEADER}
+${result.imports.join("\n")}
+
+${result.body}
+`;
+}
+function getLibraryName(filename) {
+  const base = (0, import_node_path.basename)(filename);
+  const replaced = base.replace(/NativeComponent\.[cm]?[jt]sx?$/, "");
+  return replaced === base ? base.replace(/\.[cm]?[jt]sx?$/, "") : replaced;
+}

package/dist/cjs/transformBabel.cjs

@@ -39,9 +39,7 @@ __export(transformBabel_exports, {
 });
 module.exports = __toCommonJS(transformBabel_exports);
 var import_node_path = require("node:path");
-var import_core = __toESM(require("@babel/core"), 1);
 var import_utils = require("@vxrn/utils");
-var import_babel_plugin_syntax_hermes_parser = __toESM(require("babel-plugin-syntax-hermes-parser"), 1);
 var import_vite = require("vite");
 var import_configure = require("./configure.cjs");
 var import_constants = require("./constants.cjs");
@@ -77,17 +75,16 @@ const getOptions = (props, force = false) => {
     }
   }
   if (enableNativewind || shouldBabelReanimated(props)) {
-    (0, import_constants.debug)?.(`Using babel worklets on file ${props.id}`);
-    plugins.push((0, import_utils.resolvePath)("react-native-worklets/plugin", props.projectRoot));
+    try {
+      const workletsPlugin = (0, import_utils.resolvePath)("react-native-worklets/plugin", props.projectRoot);
+      (0, import_constants.debug)?.(`Using babel worklets on file ${props.id}`);
+      plugins.push(workletsPlugin);
+    } catch {}
   }
   if (shouldBabelReactCompiler(props)) {
     (0, import_constants.debug)?.(`Using babel react compiler on file`);
     plugins.push(getBabelReactCompilerPlugin(props));
   }
-  if (shouldBabelReactNativeCodegen(props)) {
-    (0, import_constants.debug)?.(`Using babel @react-native/babel-plugin-codegen on file`);
-    plugins.push("@react-native/babel-plugin-codegen");
-  }
   if (plugins.length) {
     return {
       plugins
@@ -95,12 +92,13 @@ const getOptions = (props, force = false) => {
   }
   return null;
 };
-async function transformOxcReactCompiler(id, code, target) {
+async function transformOxcReactCompiler(id, code, target, sourceMap = false) {
   const {
     transform
   } = await import("oxc-transform-react");
   const result = await transform(id, code, {
     jsx: "preserve",
+    sourcemap: sourceMap,
     reactCompiler: {
       target
     }
@@ -113,10 +111,15 @@ async function transformOxcReactCompiler(id, code, target) {
   }
   return {
     code: result.code,
-    map: void 0
+    map: sourceMap ? result.map : void 0
   };
 }
 async function transformBabel(id, code, options) {
+  const [{
+    default: babelCore
+  }, {
+    default: hermesParserPlugin
+  }] = await Promise.all([import("@babel/core"), import("babel-plugin-syntax-hermes-parser")]);
   const extension = (0, import_node_path.extname)(id);
   const isTSX = extension === ".tsx";
   const isTS = isTSX || extension === ".ts";
@@ -140,13 +143,13 @@ async function transformBabel(id, code, options) {
     // plugins like
     // @react-native/babel-plugin-codegen silently fail on RN specs and the runtime
     // "Codegen didn't run" warning fires. TS path is byte-identical (empty slice).
-    plugins: [...(isTS ? [] : [[import_babel_plugin_syntax_hermes_parser.default, {
+    plugins: [...(isTS ? [] : [[hermesParserPlugin, {
       parseLangTypes: "flow",
       reactRuntimeTarget: "19"
     }]]), ...(options.plugins || []), ...(isTS ? [] : ["@babel/plugin-transform-flow-strip-types"])]
   };
   return await new Promise((res, rej) => {
-    import_core.default.transform(code, babelOptions, (err, result) => {
+    babelCore.transform(code, babelOptions, (err, result) => {
       if (!result || err) {
         return rej(err || new Error(`[vxrn:compiler] babel returned no result for ${id}`));
       }
@@ -163,14 +166,6 @@ const getBasePlugins = ({
   // NOTE THIS WAS SPELLED WRONG BEFOER THIS COMMIT MAYBE IT WAS UNINTENTIONALLY WORKING
   regenerator: false
 }]];
-const NATIVE_COMPONENT_RE = /NativeComponent\.[jt]sx?$/;
-const SPEC_FILE_RE = /[/\\]specs?[/\\]/;
-const shouldBabelReactNativeCodegen = ({
-  id,
-  environment
-}) => {
-  return (environment === "ios" || environment === "android") && (NATIVE_COMPONENT_RE.test(id) || SPEC_FILE_RE.test(id));
-};
 const shouldBabelReactCompiler = props => {
   if (props.environment === "ssr") {
     return false;