@react-native-native/nativ-fabric 0.1.0

package/android/src/main/java/com/nativfabric/NativRuntime.kt

@@ -0,0 +1,201 @@
+package com.nativfabric
+
+import android.content.Context
+import com.nativfabric.BuildConfig
+import android.view.View
+import android.view.ViewGroup
+import dalvik.system.DexClassLoader
+import java.io.File
+import java.lang.reflect.Method
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * NativRuntime — native function registry, .so loader, and .dex loader.
+ * Android equivalent of iOS's NativRuntime.
+ *
+ * Native (.so): render functions and sync functions registered via JNI
+ * from loaded .so files (__attribute__((constructor))).
+ *
+ * Kotlin (.dex): loaded via DexClassLoader, dispatched via reflection.
+ */
+object NativRuntime {
+
+    // Props snapshot: plain key-value maps (no JNI references)
+    data class PropsSnapshot(
+        val strings: Map<String, String> = emptyMap(),
+        val numbers: Map<String, Double> = emptyMap(),
+        val bools: Map<String, Boolean> = emptyMap(),
+    )
+
+    // Component props store
+    private val propsStore = ConcurrentHashMap<String, PropsSnapshot>()
+
+    // Loaded .so libraries
+    private val loadedLibs = ConcurrentHashMap<String, Boolean>()
+
+    // Loaded Kotlin modules: moduleId → dispatch Method
+    private val kotlinDispatch = ConcurrentHashMap<String, Method>()
+
+    // Loaded Kotlin Compose renderers: componentId → render Method
+    private val kotlinRenderers = ConcurrentHashMap<String, Method>()
+
+    // Application context (set from NativRuntimeModule)
+    var appContext: Context? = null
+
+    fun setComponentProps(componentId: String, props: PropsSnapshot) {
+        propsStore[componentId] = props
+    }
+
+    fun getComponentProps(componentId: String): PropsSnapshot? {
+        return propsStore[componentId]
+    }
+
+    fun tryRender(componentId: String, view: View, width: Float, height: Float) {
+        // Check Kotlin renderers first (View-based components from .dex)
+        val renderer = kotlinRenderers[componentId]
+        if (renderer != null && view is ViewGroup) {
+            try {
+                val props = propsStore[componentId]
+                val propsMap = mutableMapOf<String, Any?>()
+                props?.strings?.forEach { (k, v) -> propsMap[k] = v }
+                props?.numbers?.forEach { (k, v) -> propsMap[k] = v }
+                props?.bools?.forEach { (k, v) -> propsMap[k] = v }
+                renderer.invoke(null, view, propsMap)
+                return
+            } catch (e: Exception) {
+                android.util.Log.e("NativRuntime", "Kotlin render failed: ${e.message}", e)
+            }
+        }
+
+        // Fall back to native JNI render
+        val props = propsStore[componentId]
+        nativeTryRender(componentId, view, width, height,
+            props?.strings ?: emptyMap(),
+            props?.numbers ?: emptyMap(),
+            props?.bools ?: emptyMap())
+    }
+
+    fun loadLibrary(path: String): Boolean {
+        return try {
+            System.load(path)
+            loadedLibs[path] = true
+            true
+        } catch (e: UnsatisfiedLinkError) {
+            android.util.Log.e("NativRuntime", "Failed to load $path: ${e.message}")
+            false
+        }
+    }
+
+    /**
+     * Load a .dex file and register its module for dispatch.
+     * The .dex must contain a class com.nativfabric.generated.NativModule_<moduleId>
+     * with a static dispatch(String, String): String method.
+     */
+    fun loadDex(dexPath: String, moduleId: String): Boolean {
+        // Production: Kotlin is compiled into the APK by Gradle — no DexClassLoader needed
+        if (!BuildConfig.DEBUG) return false
+
+        val ctx = appContext
+        if (ctx == null) {
+            android.util.Log.e("NativRuntime", "loadDex: appContext is null!")
+            return false
+        }
+        return try {
+            val dexFile = File(dexPath)
+            val optimizedDir = File(ctx.cacheDir, "nativ_dex_opt")
+            optimizedDir.mkdirs()
+
+            // Android 14+ requires dex files to be read-only
+            dexFile.setReadOnly()
+
+            val loader = DexClassLoader(
+                dexFile.absolutePath,
+                optimizedDir.absolutePath,
+                null,
+                ctx.classLoader
+            )
+
+            val className = "com.nativfabric.generated.NativModule_$moduleId"
+            val clazz = loader.loadClass(className)
+
+            // Check for dispatch method (function module)
+            try {
+                val dispatch = clazz.getMethod("dispatch", String::class.java, String::class.java)
+                kotlinDispatch[moduleId] = dispatch
+                android.util.Log.i("NativRuntime", "Loaded Kotlin module: $moduleId")
+            } catch (_: NoSuchMethodException) {}
+
+            // Check for render method (Compose component)
+            try {
+                val render = clazz.getMethod("render", ViewGroup::class.java, Map::class.java)
+                val componentId = "nativ.$moduleId"
+                kotlinRenderers[componentId] = render
+                android.util.Log.i("NativRuntime", "Loaded Kotlin component: $componentId")
+            } catch (_: NoSuchMethodException) {}
+
+            true
+        } catch (e: Exception) {
+            android.util.Log.e("NativRuntime", "loadDex failed: ${e.message}")
+            false
+        }
+    }
+
+    /**
+     * Call a Kotlin function loaded from .dex.
+     */
+    fun callKotlin(moduleId: String, fnName: String, argsJson: String): String? {
+        val dispatch = kotlinDispatch[moduleId] ?: return null
+        return try {
+            dispatch.invoke(null, fnName, argsJson) as? String
+        } catch (e: Exception) {
+            android.util.Log.e("NativRuntime", "callKotlin failed: $moduleId::$fnName: ${e.message}")
+            null
+        }
+    }
+
+    // JNI functions — implemented in C++ (libnativruntime.so)
+    external fun nativeInit()
+    external fun nativeTryRender(
+        componentId: String, view: View, width: Float, height: Float,
+        strings: Map<String, String>, numbers: Map<String, Double>, bools: Map<String, Boolean>
+    )
+    external fun nativeCallSync(moduleId: String, fnName: String, argsJson: String): String?
+
+    init {
+        try {
+            System.loadLibrary("nativruntime")
+            nativeInit()
+        } catch (e: UnsatisfiedLinkError) {
+            android.util.Log.w("NativRuntime", "nativruntime not loaded: ${e.message}")
+        }
+
+        // Production: register Kotlin modules compiled into the APK by Gradle.
+        // In dev mode, modules are loaded via DexClassLoader (loadDex).
+        if (!BuildConfig.DEBUG) {
+            try {
+                Class.forName("com.nativfabric.generated.NativModuleRegistry")
+                    .getMethod("ensure")
+                    .invoke(null)
+                android.util.Log.i("NativRuntime", "Production: Kotlin module registry loaded")
+            } catch (e: ClassNotFoundException) {
+                // No generated modules — that's fine
+            } catch (e: Exception) {
+                android.util.Log.w("NativRuntime", "Kotlin registry failed: ${e.message}")
+            }
+        }
+    }
+
+    /** Register a Kotlin dispatch method (production — called by generated NativModuleRegistry) */
+    @JvmStatic
+    fun registerKotlinDispatch(moduleId: String, dispatch: java.lang.reflect.Method) {
+        kotlinDispatch[moduleId] = dispatch
+        android.util.Log.i("NativRuntime", "Production: registered Kotlin dispatch: $moduleId")
+    }
+
+    /** Register a Kotlin renderer method (production — called by generated NativModuleRegistry) */
+    @JvmStatic
+    fun registerKotlinRenderer(componentId: String, render: java.lang.reflect.Method) {
+        kotlinRenderers[componentId] = render
+        android.util.Log.i("NativRuntime", "Production: registered Kotlin renderer: $componentId")
+    }
+}

package/android/src/main/java/com/nativfabric/NativRuntimeModule.kt

@@ -0,0 +1,37 @@
+package com.nativfabric
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
+import com.facebook.fbreact.specs.NativeNativRuntimeSpec
+
+/**
+ * TurboModule that installs global.__nativ JSI bindings when loaded.
+ * Uses TurboModuleWithJSIBindings — RN calls installJSIBindingsWithRuntime
+ * automatically when the module is first accessed from JS.
+ *
+ * No BindingsInstaller on MainApplication.kt needed.
+ * No dependency on the old expo-ferrum module.
+ */
+@DoNotStrip
+@ReactModule(name = NativRuntimeModule.NAME)
+class NativRuntimeModule(context: ReactApplicationContext) :
+    NativeNativRuntimeSpec(context), TurboModuleWithJSIBindings {
+
+    override fun getConstants(): Map<String, Any> = emptyMap()
+
+    @DoNotStrip
+    external override fun getBindingsInstaller(): BindingsInstallerHolder
+
+    override fun getName(): String = NAME
+
+    companion object {
+        const val NAME = "NativRuntime"
+
+        init {
+            System.loadLibrary("nativruntime")
+        }
+    }
+}

package/android/src/main/java/com/nativfabric/compose/ComposeWrappers.kt

@@ -0,0 +1,45 @@
+// Non-inline wrappers for inline Compose layout functions.
+// Compiled WITH the Compose plugin so call sites get transformed correctly.
+// User code imports these instead of the inline originals.
+package com.nativfabric.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.foundation.layout.Arrangement
+
+@Composable
+fun Box(
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    propagateMinConstraints: Boolean = false,
+    content: @Composable androidx.compose.foundation.layout.BoxScope.() -> Unit
+) {
+    androidx.compose.foundation.layout.Box(modifier, contentAlignment, propagateMinConstraints, content)
+}
+
+@Composable
+fun Column(
+    modifier: Modifier = Modifier,
+    verticalArrangement: Arrangement.Vertical = Arrangement.Top,
+    horizontalAlignment: Alignment.Horizontal = Alignment.Start,
+    content: @Composable androidx.compose.foundation.layout.ColumnScope.() -> Unit
+) {
+    androidx.compose.foundation.layout.Column(modifier, verticalArrangement, horizontalAlignment, content)
+}
+
+@Composable
+fun Row(
+    modifier: Modifier = Modifier,
+    horizontalArrangement: Arrangement.Horizontal = Arrangement.Start,
+    verticalAlignment: Alignment.Vertical = Alignment.Top,
+    content: @Composable androidx.compose.foundation.layout.RowScope.() -> Unit
+) {
+    androidx.compose.foundation.layout.Row(modifier, horizontalArrangement, verticalAlignment, content)
+}
+
+@Composable
+fun Spacer(modifier: Modifier) {
+    androidx.compose.foundation.layout.Spacer(modifier)
+}
+

package/app.plugin.js

@@ -0,0 +1,159 @@
+/**
+ * React Native Native — Expo config plugin.
+ *
+ * Creates a CocoaPods pod for user native code with three fixed-name files:
+ *   - bridges/nativ_bridges.mm   — all C++/ObjC++ bridges + Swift/Rust registration
+ *   - bridges/nativ_bridges.swift — all Swift source + @_cdecl wrappers
+ *   - bridges/libnativ_user.a    — unified Rust static library
+ *
+ * Stubs are created at prebuild time (so pod install picks them up).
+ * A :before_compile script phase regenerates them with real content on Release builds.
+ * Debug builds skip the script — all native code loads via Metro dylibs.
+ */
+
+const { withDangerousMod, withXcodeProject } = require('@expo/config-plugins');
+const path = require('path');
+const fs = require('fs');
+
+function withReactNativeNative(config) {
+  config = withNativPod(config);
+  config = withPodfileEntry(config);
+  config = withForceLoad(config);
+  return config;
+}
+
+// ─── Generate .nativ/ with podspec + stub bridge files ──────────────────
+
+function withNativPod(config) {
+  return withDangerousMod(config, ['ios', (config) => {
+    const projectRoot = config.modRequest.projectRoot;
+    const pkgDir = path.join(projectRoot, '.nativ');
+    const bridgesDir = path.join(pkgDir, 'bridges');
+    fs.mkdirSync(bridgesDir, { recursive: true });
+
+    // Resolve paths relative to .nativ/ for the podspec
+    const nativFabricDir = path.resolve(__dirname);
+    const relCompiler = path.relative(pkgDir, path.join(nativFabricDir, 'metro/compilers/static-compiler.js'));
+    const relMetroDir = path.relative(pkgDir, path.join(nativFabricDir, 'metro'));
+
+    // ── Stub source files (valid code that compiles to nothing) ──
+    fs.writeFileSync(path.join(bridgesDir, 'nativ_bridges.mm'),
+      '// Stub — real bridges generated at Release build time by React Native Native\n');
+    fs.writeFileSync(path.join(bridgesDir, 'nativ_bridges.swift'),
+      '// Stub — real bridges generated at Release build time by React Native Native\nimport Foundation\n');
+    // Empty ar archive (valid .a that links to nothing)
+    fs.writeFileSync(path.join(bridgesDir, 'libnativ_user.a'), '!<arch>\n');
+
+    // ── Build script (called by CocoaPods script phase) ──
+    fs.writeFileSync(path.join(pkgDir, 'build-bridges.sh'),
+`#!/bin/bash
+set -euo pipefail
+
+if [ "\${CONFIGURATION}" = "Debug" ]; then
+  echo "[nativ] Debug build — skipping static compilation"
+  exit 0
+fi
+
+echo "[nativ] Building native bridges for Release..."
+node "$PODS_TARGET_SRCROOT/${relCompiler}" \\
+  --platform ios \\
+  --root "$PODS_TARGET_SRCROOT/.." \\
+  --output "$PODS_TARGET_SRCROOT/bridges"
+`);
+    fs.chmodSync(path.join(pkgDir, 'build-bridges.sh'), 0o755);
+
+    // ── Podspec ──
+    fs.writeFileSync(path.join(pkgDir, 'ReactNativeNativeUserCode.podspec'),
+`Pod::Spec.new do |s|
+  s.name           = 'ReactNativeNativeUserCode'
+  s.version        = '0.1.0'
+  s.summary        = 'User native code — React Native Native'
+  s.homepage       = 'https://react-native-native.dev'
+  s.license        = { :type => 'MIT' }
+  s.author         = 'Generated'
+  s.source         = { :git => '' }
+  s.platforms      = { :ios => '15.1' }
+  s.static_framework = true
+
+  s.source_files       = ['bridges/nativ_bridges.mm', 'bridges/nativ_bridges.swift']
+  s.vendored_libraries = ['bridges/libnativ_user.a']
+  s.preserve_paths     = ['bridges/*']
+
+  s.dependency 'NativFabric'
+
+  s.pod_target_xcconfig = {
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+    'HEADER_SEARCH_PATHS' => '"$(PODS_TARGET_SRCROOT)/${relMetroDir}"',
+    'OTHER_LDFLAGS' => '$(inherited) -lc++',
+  }
+
+  s.script_phase = {
+    :name => 'Build Native Bridges',
+    :script => 'bash "$PODS_TARGET_SRCROOT/build-bridges.sh"',
+    :execution_position => :before_compile,
+  }
+end
+`);
+
+    return config;
+  }]);
+}
+
+// ─── Add pod to Podfile ─────────────────────────────────────────────────
+
+function withPodfileEntry(config) {
+  return withDangerousMod(config, ['ios', (config) => {
+    const projectRoot = config.modRequest.projectRoot;
+    const podfilePath = path.join(projectRoot, 'ios', 'Podfile');
+
+    if (!fs.existsSync(podfilePath)) return config;
+
+    let podfile = fs.readFileSync(podfilePath, 'utf8');
+    const podLine = "  pod 'ReactNativeNativeUserCode', :path => File.join(__dir__, '..', '.nativ')";
+
+    if (!podfile.includes('ReactNativeNativeUserCode')) {
+      // Insert after use_expo_modules! (standard Expo Podfile location)
+      const insertIdx = podfile.indexOf('use_expo_modules!');
+      if (insertIdx !== -1) {
+        const lineEnd = podfile.indexOf('\n', insertIdx);
+        podfile = podfile.slice(0, lineEnd + 1) + podLine + '\n' + podfile.slice(lineEnd + 1);
+      } else {
+        // Fallback: insert before the last 'end' in the target block
+        const lastEnd = podfile.lastIndexOf('\nend');
+        if (lastEnd !== -1) {
+          podfile = podfile.slice(0, lastEnd) + '\n' + podLine + podfile.slice(lastEnd);
+        }
+      }
+      fs.writeFileSync(podfilePath, podfile);
+    }
+
+    return config;
+  }]);
+}
+
+// ─── Force-load constructors from static libraries in Release ───────────
+
+function withForceLoad(config) {
+  return withXcodeProject(config, (config) => {
+    const xcodeProject = config.modResults;
+    const buildSettings = xcodeProject.pbxXCBuildConfigurationSection();
+
+    for (const key of Object.keys(buildSettings)) {
+      const cfg = buildSettings[key];
+      if (typeof cfg === 'object' && cfg.name === 'Release' && cfg.buildSettings) {
+        const flags = cfg.buildSettings.OTHER_LDFLAGS || ['$(inherited)'];
+        if (!flags.includes('-all_load')) {
+          if (typeof flags === 'string') {
+            cfg.buildSettings.OTHER_LDFLAGS = [flags, '-all_load'];
+          } else {
+            flags.push('-all_load');
+          }
+        }
+      }
+    }
+
+    return config;
+  });
+}
+
+module.exports = withReactNativeNative;

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+  "platforms": ["ios"],
+  "ios": {
+    "podName": "NativFabric"
+  }
+}

package/ios/NativContainerComponentView.mm

@@ -0,0 +1,137 @@
+// NativContainerComponentView — Fabric component that hosts native views
+// rendered by Rust/C++/Swift/ObjC++ via react-native-native.
+//
+// Uses self.contentView (RCTViewComponentView built-in) to isolate our
+// rendering from Fabric's own view management. Fabric manages `self`,
+// we manage `_contentView`. No background color conflicts.
+
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+
+#include "react/renderer/components/NativFabricSpec/ComponentDescriptors.h"
+#include "react/renderer/components/NativFabricSpec/EventEmitters.h"
+#include "react/renderer/components/NativFabricSpec/Props.h"
+#include "react/renderer/components/NativFabricSpec/RCTComponentViewHelpers.h"
+
+#import "NativRuntime.h"
+
+using namespace facebook::react;
+
+@interface NativContainerComponentView : RCTViewComponentView
+@end
+
+@implementation NativContainerComponentView {
+  UIView *_contentView;
+  std::string _componentId;
+  std::string _propsJson;
+  BOOL _mounted;
+  CGSize _lastRenderedSize;
+}
+
++ (void)load {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[RCTComponentViewFactory currentComponentViewFactory]
+        registerComponentViewClass:NativContainerComponentView.class];
+  });
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<NativContainerComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const NativContainerProps>();
+    _props = defaultProps;
+
+    _contentView = [[UIView alloc] init];
+    _contentView.clipsToBounds = YES;
+    self.contentView = _contentView;
+
+    _mounted = NO;
+  }
+  return self;
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  auto const &newProps = *std::static_pointer_cast<NativContainerProps const>(props);
+
+  bool componentChanged = (_componentId != newProps.componentId);
+  bool propsChanged = (_propsJson != newProps.propsJson);
+
+  _componentId = newProps.componentId;
+  _propsJson = newProps.propsJson;
+
+  if (componentChanged) {
+    _mounted = NO;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+
+  if ((componentChanged || propsChanged) && !_componentId.empty()) {
+    CGSize size = _contentView.bounds.size;
+    if (!_mounted && size.width > 0 && size.height > 0) {
+      [self _fullRender];
+    } else if (_mounted) {
+      [self _updateRender];
+    }
+  }
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+
+  // Sync contentView frame to self
+  _contentView.frame = self.bounds;
+
+  CGSize size = _contentView.bounds.size;
+  if (!_componentId.empty() && size.width > 0 && size.height > 0) {
+    if (!_mounted) {
+      _lastRenderedSize = size;
+      [self _fullRender];
+    } else if (!CGSizeEqualToSize(size, _lastRenderedSize)) {
+      _lastRenderedSize = size;
+      [self _updateRender];
+    }
+  }
+}
+
+- (void)_fullRender {
+  [self _clearContentView];
+  extern const char* nativ_try_render(const char*, void*, float, float);
+  const char* result = nativ_try_render(
+    _componentId.c_str(), (__bridge void*)_contentView,
+    _contentView.bounds.size.width, _contentView.bounds.size.height);
+  if (result) {
+    _mounted = YES;
+  }
+}
+
+- (void)_updateRender {
+  [self _clearContentView];
+  extern const char* nativ_try_render(const char*, void*, float, float);
+  nativ_try_render(
+    _componentId.c_str(), (__bridge void*)_contentView,
+    _contentView.bounds.size.width, _contentView.bounds.size.height);
+}
+
+- (void)_clearContentView {
+  for (UIView *sub in [_contentView.subviews copy]) {
+    [sub removeFromSuperview];
+  }
+  for (CALayer *sub in [_contentView.layer.sublayers copy]) {
+    [sub removeFromSuperlayer];
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  _componentId.clear();
+  _propsJson.clear();
+  _mounted = NO;
+  _lastRenderedSize = CGSizeZero;
+  [self _clearContentView];
+}
+
+@end

package/ios/NativRuntime.h

@@ -0,0 +1,36 @@
+#pragma once
+
+// C ABI function types
+typedef const char* (*NativSyncFn)(const char*);
+typedef void (*NativAsyncFn)(const char*, void (*)(const char*), void (*)(const char*, const char*));
+typedef void (*NativRenderFn)(void*, float, float, void*, void*);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void nativ_register_sync(const char* moduleId, const char* fnName, NativSyncFn fn);
+void nativ_register_async(const char* moduleId, const char* fnName, NativAsyncFn fn);
+void nativ_register_render(const char* componentId, NativRenderFn fn);
+const char* nativ_try_render(const char* componentId, void* view, float w, float h);
+
+// JSI value access (C wrappers for Rust/Swift)
+const char* nativ_jsi_get_string(void* runtime, void* object, const char* prop_name);
+double nativ_jsi_get_number(void* runtime, void* object, const char* prop_name);
+int nativ_jsi_get_bool(void* runtime, void* object, const char* prop_name);
+int nativ_jsi_has_prop(void* runtime, void* object, const char* prop_name);
+void nativ_jsi_call_function(void* runtime, void* object, const char* prop_name);
+void nativ_jsi_call_function_with_string(void* runtime, void* object, const char* prop_name, const char* arg);
+
+// Type checking
+int nativ_jsi_is_array(void* runtime, void* object, const char* prop_name);
+int nativ_jsi_get_array_length(void* runtime, void* object, const char* prop_name);
+int nativ_jsi_is_object(void* runtime, void* object, const char* prop_name);
+int nativ_jsi_is_null(void* runtime, void* object, const char* prop_name);
+
+// Entry point for expo-ferrum backward compatibility
+void nativ_cpp_install(void *runtimePtr);
+
+#ifdef __cplusplus
+}
+#endif