@react-native-native/nativ-fabric 0.1.0

package/metro/compilers/swift-compiler.js

@@ -0,0 +1,363 @@
+/**
+ * Compiles a .swift file to a signed arm64 iOS dylib.
+ * Same pattern as dylib-compiler.js for C++ and rust-compiler.js for Rust.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+let _sdkPaths = {};
+let _signingIdentity = null;
+let _resolved = false;
+
+function getSdkPath(target) {
+  if (_sdkPaths[target]) return _sdkPaths[target];
+  const sdk = target === 'simulator' ? 'iphonesimulator' : 'iphoneos';
+  try {
+    _sdkPaths[target] = execSync(`xcrun --sdk ${sdk} --show-sdk-path`, {
+      encoding: 'utf8',
+    }).trim();
+  } catch {}
+  return _sdkPaths[target] || null;
+}
+
+function resolveOnce(projectRoot) {
+  if (_resolved) return;
+  _resolved = true;
+
+  try {
+    let appTeamId = null;
+    try {
+      const appJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'app.json'), 'utf8'));
+      appTeamId = appJson?.expo?.ios?.appleTeamId || null;
+    } catch {}
+
+    if (!appTeamId) {
+      try {
+        const pbx = execSync(
+          `find "${projectRoot}/ios" -name "project.pbxproj" -maxdepth 3 2>/dev/null`,
+          { encoding: 'utf8' }
+        ).trim().split('\n')[0];
+        if (pbx) {
+          const m = fs.readFileSync(pbx, 'utf8').match(/DEVELOPMENT_TEAM\s*=\s*(\w+)/);
+          if (m) appTeamId = m[1];
+        }
+      } catch {}
+    }
+
+    if (appTeamId) {
+      const identities = execSync('security find-identity -v -p codesigning', {
+        encoding: 'utf8',
+      });
+      const entries = [...identities.matchAll(/([A-F0-9]{40})\s+"([^"]+)"/g)];
+      for (const [, , name] of entries) {
+        try {
+          const subject = execSync(
+            `security find-certificate -c "${name}" -p 2>/dev/null | openssl x509 -noout -subject 2>/dev/null`,
+            { encoding: 'utf8' }
+          );
+          if (subject.includes(`OU=${appTeamId}`)) {
+            _signingIdentity = name;
+            break;
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+}
+
+/**
+ * Extract Swift function exports: @_cdecl functions with nativ_ prefix.
+ */
+function extractSwiftExports(filepath) {
+  let src;
+  try { src = fs.readFileSync(filepath, 'utf8'); } catch { return []; }
+
+  const moduleId = path.basename(filepath, '.swift').toLowerCase();
+  const exports = [];
+
+  // Match: // @nativ_export or // @nativ_export(sync) or // @nativ_export(sync, main)
+  const pattern = /\/\/\s*@?nativ_export(?:\s*\(\s*([^)]*)\s*\))?\s*\n\s*(?:@_cdecl\s*\([^)]*\)\s*\n\s*)?func\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*(\S+))?\s*\{/g;
+  let match;
+  while ((match = pattern.exec(src)) !== null) {
+    const [, modeStr, name, argsStr, retType] = match;
+    const flags = (modeStr || '').split(',').map(s => s.trim());
+    const cdeclName = `nativ_swift_${moduleId}_${name}`;
+
+    // Parse args (skip _ labels and UnsafePointer types from old-style exports)
+    const args = argsStr.trim()
+      ? argsStr.split(',').map(a => {
+          const m = a.trim().match(/(?:\w+\s+)?(\w+)\s*:\s*(.+)/);
+          return m ? { name: m[1], type: m[2].trim() } : null;
+        }).filter(Boolean).filter(a => !a.type.includes('UnsafePointer'))
+      : [];
+
+    exports.push({
+      name,
+      async: flags.includes('async'),
+      mainThread: flags.includes('main'),
+      cdeclName,
+      args,
+      ret: retType || 'Void',
+    });
+  }
+
+  return exports;
+}
+
+function compileSwiftDylib(filepath, projectRoot, { target = 'device' } = {}) {
+  resolveOnce(projectRoot);
+  const sdkPath = getSdkPath(target);
+  if (!sdkPath) return null;
+
+  const targetTriple = target === 'simulator'
+    ? 'arm64-apple-ios15.1-simulator'
+    : 'arm64-apple-ios15.1';
+
+  const name = path.basename(filepath, '.swift');
+  const moduleId = name.toLowerCase();
+  const outputDir = path.join(projectRoot, '.nativ/dylibs', target);
+  fs.mkdirSync(outputDir, { recursive: true });
+  const _isComp = (() => {
+    try { return fs.readFileSync(filepath, 'utf8').includes('@nativ_component'); } catch { return false; }
+  })();
+  const dylibName = _isComp ? `nativ_${moduleId}` : moduleId;
+  const dylibPath = path.join(outputDir, `${dylibName}.dylib`);
+
+  // Generate Swift bridge with @_cdecl wrappers + C registration file
+  const exports = extractSwiftExports(filepath);
+
+  // Check if this is a component (has @nativ_component or nativ::component)
+  const userSrc = fs.readFileSync(filepath, 'utf8');
+  const isComponent = userSrc.includes('@nativ_component') || userSrc.includes('nativ::component');
+
+  if (isComponent) {
+    // Parse the SwiftUI View struct to extract props
+    const structMatch = userSrc.match(/\/\/\s*@nativ_component\s*\n\s*struct\s+(\w+)\s*:\s*View\s*\{([\s\S]*?)var\s+body\s*:\s*some\s+View/);
+    const structName = structMatch ? structMatch[1] : name;
+    const propsBlock = structMatch ? structMatch[2] : '';
+
+    // Parse fields: let title: String, let count: Int, var opacity: Double = 1.0
+    const props = [];
+    for (const line of propsBlock.split('\n')) {
+      const m = line.trim().match(/(?:let|var)\s+(\w+)\s*:\s*(\w+)/);
+      if (m) {
+        const [, propName, propType] = m;
+        if (!['body'].includes(propName)) {
+          props.push({ name: propName, type: propType });
+        }
+      }
+    }
+
+    // Generate Swift bridge file with render function + JSI prop extraction
+    const swiftBridgePath = path.join(outputDir, `${moduleId}_bridge.swift`);
+    const renderFnName = `nativ_${moduleId}_render`;
+
+    const propExtractions = props.map(p => {
+      if (p.type === 'String') {
+        return `    let ${p.name} = String(cString: nativ_jsi_get_string(runtime, props, "${p.name}"))`;
+      } else if (p.type === 'Double' || p.type === 'Float' || p.type === 'CGFloat') {
+        return `    let ${p.name} = ${p.type}(nativ_jsi_get_number(runtime, props, "${p.name}"))`;
+      } else if (p.type === 'Int') {
+        return `    let ${p.name} = Int(nativ_jsi_get_number(runtime, props, "${p.name}"))`;
+      } else if (p.type === 'Bool') {
+        return `    let ${p.name} = nativ_jsi_has_prop(runtime, props, "${p.name}") != 0 && nativ_jsi_get_number(runtime, props, "${p.name}") != 0`;
+      } else if (p.type === 'Color') {
+        return `    let ${p.name}: Color = {
+        let hex = String(cString: nativ_jsi_get_string(runtime, props, "${p.name}"))
+        let scanner = Scanner(string: hex.hasPrefix("#") ? String(hex.dropFirst()) : hex)
+        var rgb: UInt64 = 0; scanner.scanHexInt64(&rgb)
+        return Color(red: Double((rgb >> 16) & 0xFF) / 255, green: Double((rgb >> 8) & 0xFF) / 255, blue: Double(rgb & 0xFF) / 255)
+    }()`;
+      } else {
+        return `    // TODO: unsupported prop type ${p.type} for ${p.name}`;
+      }
+    });
+
+    // Build the struct initializer args
+    const initArgs = props.map(p => {
+      if (p.type === 'Color') {
+        return `${p.name}: Color(red: nativ_jsi_get_number(runtime, props, "r"), green: nativ_jsi_get_number(runtime, props, "g"), blue: nativ_jsi_get_number(runtime, props, "b"))`;
+      }
+      return `${p.name}: ${p.name}`;
+    }).join(', ');
+
+    const bridgeSwift = `import SwiftUI
+import UIKit
+
+// Auto-generated bridge for ${structName}
+
+@_cdecl("${renderFnName}")
+func ${renderFnName}(
+    _ view: UnsafeMutableRawPointer,
+    _ width: Float, _ height: Float,
+    _ runtime: UnsafeMutableRawPointer?,
+    _ props: UnsafeMutableRawPointer?
+) {
+    let parentView = Unmanaged<UIView>.fromOpaque(view).takeUnretainedValue()
+
+    // Extract props via JSI C API
+${propExtractions.join('\n')}
+
+    let swiftUIView = ${structName}(${initArgs})
+    let hostingController = UIHostingController(rootView: swiftUIView)
+    hostingController.view.frame = CGRect(x: 0, y: 0, width: CGFloat(width), height: CGFloat(height))
+    hostingController.view.backgroundColor = .clear
+
+    objc_setAssociatedObject(parentView, "nativHosting", hostingController, .OBJC_ASSOCIATION_RETAIN)
+    parentView.addSubview(hostingController.view)
+}
+
+// JSI C API — resolved at dlopen time via -undefined dynamic_lookup
+@_silgen_name("nativ_jsi_get_string")
+func nativ_jsi_get_string(_ rt: UnsafeMutableRawPointer?, _ obj: UnsafeMutableRawPointer?, _ name: UnsafePointer<CChar>) -> UnsafePointer<CChar>
+
+@_silgen_name("nativ_jsi_get_number")
+func nativ_jsi_get_number(_ rt: UnsafeMutableRawPointer?, _ obj: UnsafeMutableRawPointer?, _ name: UnsafePointer<CChar>) -> Double
+
+@_silgen_name("nativ_jsi_has_prop")
+func nativ_jsi_has_prop(_ rt: UnsafeMutableRawPointer?, _ obj: UnsafeMutableRawPointer?, _ name: UnsafePointer<CChar>) -> Int32
+`;
+    fs.writeFileSync(swiftBridgePath, bridgeSwift);
+
+    // C registration file
+    const cBridgePath = path.join(outputDir, `${moduleId}_reg.c`);
+    fs.writeFileSync(cBridgePath, `
+typedef void (*NativRenderFn)(void*, float, float, void*, void*);
+extern void nativ_register_render(const char*, NativRenderFn);
+extern void ${renderFnName}(void*, float, float, void*, void*);
+
+__attribute__((constructor))
+void nativ_register_${moduleId}(void) {
+  nativ_register_render("nativ.${moduleId}", ${renderFnName});
+}
+`);
+
+    const cmd = [
+      'swiftc',
+      '-emit-library',
+      '-target', targetTriple,
+      '-sdk', sdkPath,
+      '-Xlinker', '-undefined',
+      '-Xlinker', 'dynamic_lookup',
+      '-o', dylibPath,
+      filepath,
+      swiftBridgePath,
+      cBridgePath,
+    ];
+
+    console.log(`[nativ] Compiling ${name}.swift component via swiftc...`);
+    try {
+      execSync(cmd.join(' '), { stdio: 'pipe', encoding: 'utf8' });
+    } catch (err) {
+      console.error(`[nativ] Swift compile failed: ${name}.swift`);
+      console.error((err.stderr || '').slice(0, 2000));
+      return null;
+    }
+
+    if (_signingIdentity) {
+      try { execSync(`codesign -fs "${_signingIdentity}" "${dylibPath}"`, { stdio: 'pipe' }); } catch {}
+    }
+
+    const size = fs.statSync(dylibPath).size;
+    console.log(`[nativ] Built ${moduleId}.dylib component (${(size / 1024).toFixed(1)}KB)`);
+    return { dylibPath, exports: [], isComponent: true };
+  }
+
+  // Function exports: generate Swift + C bridges
+  const swiftBridgePath = path.join(outputDir, `${moduleId}_bridge.swift`);
+  let swiftWrappers = 'import Foundation\n';
+  swiftWrappers += exports.map(fn => {
+    const retType = fn.ret || 'Void';
+    const argPassthrough = fn.args.map(a => a.name).join(', ');
+
+    let resultExpr;
+    if (retType === 'String') {
+      resultExpr = `UnsafePointer(strdup("\\"" + result + "\\"")!)`;
+    } else if (retType === 'Bool') {
+      resultExpr = `UnsafePointer(strdup(result ? "true" : "false")!)`;
+    } else if (retType === 'Void') {
+      resultExpr = `UnsafePointer(strdup("null")!)`;
+    } else {
+      resultExpr = `UnsafePointer(strdup(String(result))!)`;
+    }
+
+    if (fn.mainThread) {
+      return `
+@_cdecl("${fn.cdeclName}")
+func _nativ_${fn.name}(_ argsJson: UnsafePointer<CChar>) -> UnsafePointer<CChar> {
+    var ptr: UnsafePointer<CChar>!
+    DispatchQueue.main.sync {
+        let result = ${fn.name}(${argPassthrough})
+        ptr = ${resultExpr}
+    }
+    return ptr
+}`;
+    }
+
+    return `
+@_cdecl("${fn.cdeclName}")
+func _nativ_${fn.name}(_ argsJson: UnsafePointer<CChar>) -> UnsafePointer<CChar> {
+    let result = ${fn.name}(${argPassthrough})
+    return ${resultExpr}
+}`;
+  }).join('\n');
+
+  fs.writeFileSync(swiftBridgePath, swiftWrappers.toString());
+
+  // C registration file
+  const cBridgePath = path.join(outputDir, `${moduleId}_reg.c`);
+  const registrations = exports.map(fn =>
+    `  nativ_register_sync("${moduleId}", "${fn.name}", ${fn.cdeclName});`
+  ).join('\n');
+  const declarations = exports.map(fn =>
+    `extern const char* ${fn.cdeclName}(const char*);`
+  ).join('\n');
+
+  fs.writeFileSync(cBridgePath, `
+typedef const char* (*NativSyncFn)(const char*);
+extern void nativ_register_sync(const char*, const char*, NativSyncFn);
+${declarations}
+
+__attribute__((constructor))
+void nativ_register_${moduleId}(void) {
+${registrations}
+}
+`);
+
+  const cmd = [
+    'swiftc',
+    '-emit-library',
+    '-target', targetTriple,
+    '-sdk', sdkPath,
+    '-Xlinker', '-undefined',
+    '-Xlinker', 'dynamic_lookup',
+    '-o', dylibPath,
+    filepath,
+    swiftBridgePath,
+    cBridgePath,
+  ];
+
+  console.log(`[nativ] Compiling ${name}.swift via swiftc...`);
+  try {
+    execSync(cmd.join(' '), { stdio: 'pipe', encoding: 'utf8' });
+  } catch (err) {
+    console.error(`[nativ] Swift compile failed: ${name}.swift`);
+    console.error((err.stderr || '').slice(0, 2000));
+    return null;
+  }
+
+  // Sign
+  if (_signingIdentity) {
+    try {
+      execSync(`codesign -fs "${_signingIdentity}" "${dylibPath}"`, { stdio: 'pipe' });
+    } catch {}
+  }
+
+  const size = fs.statSync(dylibPath).size;
+  console.log(`[nativ] Built ${moduleId}.dylib (${(size / 1024).toFixed(1)}KB)`);
+  return { dylibPath, exports };
+}
+
+module.exports = { compileSwiftDylib, extractSwiftExports };

package/metro/extractors/cpp-ast-extractor.js

@@ -0,0 +1,126 @@
+/**
+ * Extracts NATIV_EXPORT annotated functions from C++/ObjC++ files.
+ *
+ * Uses regex to find NATIV_EXPORT annotations and parse function signatures.
+ * This is simpler and more portable than relying on clang's JSON AST dump
+ * (which doesn't include annotation values in all versions).
+ */
+
+const fs = require('fs');
+
+/**
+ * Parse a C++/ObjC++ file and return all NATIV_EXPORT-annotated function declarations.
+ *
+ * @param {string} filename — absolute path to .cpp/.mm file
+ * @param {string[]} _includePaths — unused (kept for API compat)
+ * @returns {{ name: string, async: boolean, args: { name: string, type: string }[], ret: string }[]}
+ */
+function isCppComponent(filename) {
+  try {
+    const src = fs.readFileSync(filename, 'utf8');
+    return src.includes('nativ::component') || src.includes('NATIV_COMPONENT') || src.includes('NATIV_COMPONENT');
+  } catch {
+    return false;
+  }
+}
+
+function extractCppExports(filename, _includePaths) {
+  let src;
+  try {
+    src = fs.readFileSync(filename, 'utf8');
+  } catch {
+    return [];
+  }
+
+  const exports = [];
+
+  // Match: NATIV_EXPORT(sync|async[, main])\n<return_type> <name>(<args>)
+  // Supports: NATIV_EXPORT(sync), NATIV_EXPORT(async), NATIV_EXPORT(sync, main)
+  const pattern = /NATIV_EXPORT\s*\(\s*([^)]+)\s*\)\s*\n\s*(.+?)\s+(\w+)\s*\(([^)]*)\)/g;
+
+  let match;
+  while ((match = pattern.exec(src)) !== null) {
+    const [, modeStr, retType, name, argsStr] = match;
+    const flags = modeStr.split(',').map(s => s.trim());
+    const mode = flags[0]; // 'sync' or 'async'
+    const mainThread = flags.includes('main');
+
+    const args = argsStr
+      .split(',')
+      .map(a => a.trim())
+      .filter(Boolean)
+      .map(arg => {
+        // Parse "const std::string& name" → { type: "const std::string&", name: "name" }
+        const parts = arg.match(/^(.+?)\s+(\w+)$/);
+        if (parts) {
+          return { type: parts[1].trim(), name: parts[2] };
+        }
+        return { type: arg, name: '_unnamed' };
+      });
+
+    exports.push({
+      name,
+      async: mode === 'async',
+      mainThread,
+      args,
+      ret: retType.trim(),
+    });
+  }
+
+  return exports;
+}
+
+/**
+ * Extract component props from a C++ props struct.
+ * Parses: struct XxxProps { std::string title = "default"; double opacity = 1.0; ... };
+ */
+function extractCppComponentProps(filename) {
+  let src;
+  try { src = fs.readFileSync(filename, 'utf8'); } catch { return []; }
+
+  // Find NATIV_COMPONENT(name, PropsType)
+  const compMatch = src.match(/NATIV_COMPONENT\s*\(\s*(\w+)\s*,\s*(\w+)\s*\)/);
+  if (!compMatch) return [];
+
+  const propsTypeName = compMatch[2];
+
+  // Find the struct definition
+  const structRegex = new RegExp(`struct\\s+${propsTypeName}\\s*\\{([^}]*)\\}`, 's');
+  const structMatch = src.match(structRegex);
+  if (!structMatch) return [];
+
+  const props = [];
+  const CPP_TO_TS = {
+    'std::string': 'string',
+    'double': 'number',
+    'float': 'number',
+    'int': 'number',
+    'int32_t': 'number',
+    'bool': 'boolean',
+    'std::function<void()>': '(() => void)',
+    'std::function<void(std::string)>': '((arg: string) => void)',
+  };
+
+  for (const line of structMatch[1].split('\n')) {
+    const trimmed = line.trim().replace(/;$/, '').trim();
+    if (!trimmed || trimmed.startsWith('//')) continue;
+
+    // Match: type name = default  or  type name
+    const fieldMatch = trimmed.match(/^(.+?)\s+(\w+)(?:\s*=\s*(.+))?$/);
+    if (!fieldMatch) continue;
+
+    const [, cppType, name, defaultVal] = fieldMatch;
+    const cleanType = cppType.trim();
+
+    // snake_case → camelCase
+    const jsName = name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+
+    const tsType = CPP_TO_TS[cleanType] || 'unknown';
+
+    props.push({ name, jsName, cppType: cleanType, tsType, defaultVal: defaultVal?.trim() });
+  }
+
+  return props;
+}
+
+module.exports = { extractCppExports, isCppComponent, extractCppComponentProps };

package/metro/extractors/kotlin-extractor.js

@@ -0,0 +1,125 @@
+/**
+ * kotlin-extractor.js — extracts @nativ_export functions and @nativ_component
+ * annotations from Kotlin source files.
+ *
+ * Mirrors rust-extractor.js / cpp-ast-extractor.js for the Kotlin path.
+ */
+
+const fs = require('fs');
+
+// Kotlin type → TypeScript type mapping
+const typeMap = {
+  'Int': 'number',
+  'Long': 'number',
+  'Float': 'number',
+  'Double': 'number',
+  'Boolean': 'boolean',
+  'String': 'string',
+  'Unit': 'void',
+};
+
+function tsType(ktType) {
+  return typeMap[ktType] || 'any';
+}
+
+/**
+ * Extract exported functions and component info from a .kt file.
+ *
+ * Annotations (in comments, like Swift):
+ *   // @nativ_export(sync)
+ *   fun fibonacci(n: Int): Int { ... }
+ *
+ *   // @nativ_component
+ *   @Composable
+ *   fun Counter(count: Int, onPress: () -> Unit) { ... }
+ */
+function extractKotlinExports(filepath) {
+  const src = fs.readFileSync(filepath, 'utf8');
+  const lines = src.split('\n');
+  const functions = [];
+  let isComponent = false;
+  const componentProps = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+
+    // Check for // @nativ_export or // @nativ_component
+    const exportMatch = line.match(/\/\/\s*@nativ_export\s*\(?\s*(sync|async)?\s*\)?/);
+    const componentMatch = line.match(/\/\/\s*@nativ_component/);
+
+    if (exportMatch) {
+      const isAsync = exportMatch[1] === 'async';
+      // Find the next `fun` declaration
+      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+        const fnLine = lines[j].trim();
+        const fnMatch = fnLine.match(/fun\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*(\S+))?/);
+        if (fnMatch) {
+          const name = fnMatch[1];
+          const argsStr = fnMatch[2].trim();
+          const ret = fnMatch[3] || 'Unit';
+
+          const args = [];
+          if (argsStr) {
+            // Parse "name: Type, name2: Type2"
+            for (const part of argsStr.split(',')) {
+              const argMatch = part.trim().match(/(\w+)\s*:\s*(\S+)/);
+              if (argMatch) {
+                args.push({
+                  name: argMatch[1],
+                  type: argMatch[2],
+                  tsType: tsType(argMatch[2]),
+                });
+              }
+            }
+          }
+
+          functions.push({
+            name,
+            args,
+            ret,
+            tsType: tsType(ret),
+            async: isAsync,
+          });
+          i = j;
+          break;
+        }
+      }
+    }
+
+    if (componentMatch) {
+      isComponent = true;
+      // Find the next @Composable fun
+      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+        const fnLine = lines[j].trim();
+        const fnMatch = fnLine.match(/fun\s+\w+\s*\(([^)]*)\)/);
+        if (fnMatch) {
+          const argsStr = fnMatch[1].trim();
+          if (argsStr) {
+            for (const part of argsStr.split(',')) {
+              const argMatch = part.trim().match(/(\w+)\s*:\s*(.+)/);
+              if (argMatch) {
+                const pName = argMatch[1];
+                const pType = argMatch[2].trim();
+                // Skip callback types for props (they stay as callbacks)
+                const isCallback = pType.includes('->');
+                componentProps.push({
+                  name: pName,
+                  jsName: pName,
+                  ktType: pType,
+                  tsType: isCallback ? '() => void' : tsType(pType),
+                  isCallback,
+                });
+              }
+            }
+          }
+          i = j;
+          break;
+        }
+      }
+    }
+  }
+
+  return { functions, isComponent, componentProps };
+}
+
+module.exports = { extractKotlinExports };