feat: replace RCTStubTurboModule with C++ StubTurboModuleCxx implementation

- Remove getModuleClassFromName: and getModuleInstanceFromClass: methods
- Implement pure C++ TurboModule stub that works via getTurboModule:jsInvoker:
- Use RCTLogWarn for proper React Native logging
- Add C++ compilation guards for umbrella header compatibility
- Update podspec to include .cpp/.mm files and C++17 standard

Author: alexbabrykovich

packages/react-native-multinstance/React-MultInstance.podspec

@@ -11,14 +11,15 @@ Pod::Spec.new do |s|
   s.authors      = { "Alex Babrykovich" => "aliaksandr.babrykovich@callstack.com" } # Please update this
   s.platforms    = { :ios => "12.4" }
   s.source       = { :git => "https://github.com/callstackincubator/multi-instance-poc.git", :tag => "#{s.version}" } # Please update this
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.source_files = "ios/**/*.{h,m,mm,cpp,swift}"
   s.dependency "React-Core"
   s.dependency "React-RCTAppDelegate"
+  s.dependency "ReactAppDependencyProvider"
   s.dependency "ReactCommon"
-  # s.dependency "RCT-Folly"
   s.pod_target_xcconfig = {
     "DEFINES_MODULE" => "YES",
     "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
     "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
   }
 end

packages/react-native-multinstance/ios/SandboxReactNativeDelegate.h

@@ -12,13 +12,33 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+/**
+ * A React Native delegate that provides sandboxed environments with filtered module access.
+ * This delegate uses RCTFilteredAppDependencyProvider to restrict which native modules
+ * are available to the JavaScript runtime, enhancing security in multi-instance scenarios.
+ */
 @interface SandboxReactNativeDelegate : RCTDefaultReactNativeFactoryDelegate
 
 @property (nonatomic, copy, nullable) RCTDirectEventBlock onMessageHost;
 @property (nonatomic, copy, nullable) RCTDirectEventBlock onErrorHost;
+
+/**
+ * Sets the list of allowed TurboModules for this sandbox instance.
+ * Only modules in this list will be accessible to the JavaScript runtime.
+ */
 @property (nonatomic, copy) NSArray<NSString *> *allowedTurboModules;
 
+/**
+ * Initializes the delegate with a specific JS bundle source.
+ * @param jsBundleSource The source for the JavaScript bundle (file path or URL)
+ * @return Initialized delegate instance with filtered module access
+ */
 - (instancetype)initWithJSBundleSource:(NSString *)jsBundleSource;
+
+/**
+ * Posts a message to the JavaScript runtime.
+ * @param message Dictionary containing the message data
+ */
 - (void)postMessage:(NSDictionary *)message;
 
 @end

packages/react-native-multinstance/ios/SandboxReactNativeDelegate.mm

@@ -6,6 +6,7 @@
 //
 
 #import "SandboxReactNativeDelegate.h"
+#import "StubTurboModuleCxx.h"
 
 #include <memory>
 #include <jsi/decorator.h>
@@ -207,9 +208,14 @@ - (void)hostDidStart:(RCTHost *)host {
 }
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
-                                                      jsInvoker:
-(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker {
-  return _allowedModules.contains(name) ? [super getTurboModule:name jsInvoker:jsInvoker] : nullptr;
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker {
+  if (_allowedModules.contains(name)) {
+    return [super getTurboModule:name jsInvoker:jsInvoker];
+  } else {
+    NSLog(@"SandboxReactNativeDelegate.getTurboModule: blocking access to C++ TurboModule '%s', returning C++ stub", name.c_str());
+    // Return C++ stub instead of nullptr
+    return std::make_shared<facebook::react::StubTurboModuleCxx>(name, jsInvoker);
+  }
 }
 
 @end

packages/react-native-multinstance/ios/StubTurboModuleCxx.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#ifdef __cplusplus
+
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+namespace facebook {
+namespace react {
+
+/**
+ * A C++ TurboModule stub implementation that intercepts all method calls for blocked modules.
+ * This prevents crashes when sandbox code tries to access disallowed modules while logging warnings.
+ */
+class StubTurboModuleCxx : public TurboModule {
+ public:
+  /**
+   * Creates a stub for the specified module name
+   * @param moduleName The name of the blocked module
+   * @param jsInvoker The JavaScript invoker for communication
+   */
+  StubTurboModuleCxx(const std::string& moduleName, std::shared_ptr<CallInvoker> jsInvoker);
+  
+  /**
+   * Intercepts all method calls and returns safe default values
+   * This is the main method that gets called for any TurboModule method invocation
+   */
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
+
+ private:
+  std::string moduleName_;
+  
+  /**
+   * Logs a warning message about the blocked module access
+   */
+  void logBlockedAccess(const std::string& methodName) const;
+  
+  /**
+   * Creates a stub function that logs warnings and returns safe values
+   */
+  jsi::Function createStubFunction(jsi::Runtime& runtime, const std::string& methodName) const;
+};
+
+} // namespace react
+} // namespace facebook
+
+#endif // __cplusplus 

packages/react-native-multinstance/ios/StubTurboModuleCxx.mm

@@ -0,0 +1,45 @@
+#include "StubTurboModuleCxx.h"
+#import <React/RCTLog.h>
+
+namespace facebook {
+namespace react {
+
+StubTurboModuleCxx::StubTurboModuleCxx(const std::string& moduleName, std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule("StubTurboModuleCxx", jsInvoker), moduleName_(moduleName) {
+  logBlockedAccess("constructor");
+}
+
+jsi::Value StubTurboModuleCxx::get(jsi::Runtime& runtime, const jsi::PropNameID& propName) {
+  // Get the property name as a string
+  std::string methodName = propName.utf8(runtime);
+  
+  // Log the blocked access attempt
+  logBlockedAccess(methodName);
+  
+  // Return a stub function that will handle any method calls
+  return createStubFunction(runtime, methodName);
+}
+
+void StubTurboModuleCxx::logBlockedAccess(const std::string& methodName) const {
+  RCTLogWarn(@"[StubTurboModuleCxx] Blocked access to method '%s' on disallowed module '%s'. This module is blocked as unsafe, please add it to allowedTurboModules in SandboxReactNativeView.", 
+             methodName.c_str(), moduleName_.c_str());
+}
+
+jsi::Function StubTurboModuleCxx::createStubFunction(jsi::Runtime& runtime, const std::string& methodName) const {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, methodName.c_str()),
+    0, // number of parameters - we accept any number
+    [this, methodName](jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value {
+      // Log the method call attempt using React Native API
+      RCTLogWarn(@"[StubTurboModuleCxx] Method call '%s' blocked on module '%s'. This module is blocked as unsafe, please add it to allowedTurboModules in SandboxReactNativeView.", 
+                 methodName.c_str(), this->moduleName_.c_str());
+      
+      // Fail fast - just return undefined for all cases
+      return jsi::Value::undefined();
+    }
+  );
+}
+
+} // namespace react
+} // namespace facebook 

packages/react-native-multinstance/src/index.tsx

@@ -4,7 +4,34 @@ import type {
   DirectEventHandler,
 } from 'react-native/Libraries/Types/CodegenTypes';
 
-const SANDBOX_TURBOMODULES_WHITELIST = ['NativeMicrotasksCxx'];
+const SANDBOX_TURBOMODULES_WHITELIST = [
+  'NativeMicrotasksCxx',
+  'RedBox',
+  'DevMenu',
+  'DevLoadingView',
+  'EventDispatcher',
+  'ImageLoader',
+  'ExceptionsManager',
+  'PlatformConstants',
+  'DevSettings',
+  'SettingsManager',
+  'AppState',
+  'SourceCode',
+  'WebSocketModule',
+  'Networking',
+  'DeviceInfo',
+  'AccessibilityManager',
+  'LinkingManager',
+  'BlobModule',
+  'NativeEventEmitter',
+  'LogBox',
+  'Appearance',
+  'ReactDevToolsRuntimeSettingsModule',
+  'NativeReactNativeFeatureFlagsCxx',
+  //'NativeAnimatedTurboModule',
+  'KeyboardObserver',
+  //'FrameRateLogger',
+];
 
 type GenericProps = {
   [key: string]: any;