feat: add React Native UIKit runtime primitives

.github/workflows/ci.yml

@@ -53,5 +53,6 @@ jobs:
           IOS_TEST_TIMEOUT_MS: "600000"
           IOS_TEST_INACTIVITY_TIMEOUT_MS: "180000"
           IOS_LOG_JUNIT: "1"
+          IOS_TEST_VERBOSE_SPECS: "1"
           IOS_SIMCTL_QUERY_TIMEOUT_MS: "10000"
         run: npm run test:ios

NativeScript/CMakeLists.txt

@@ -323,6 +323,7 @@ if(ENABLE_JS_RUNTIME)
     runtime/modules/app/App.mm
     runtime/modules/web/Web.mm
     runtime/NativeScript.mm
+    cli/BundleLoader.mm
     runtime/RuntimeConfig.cpp
     runtime/modules/url/ada/ada.cpp
     runtime/modules/url/URL.cpp

NativeScript/cli/BundleLoader.mm

@@ -1,50 +1,148 @@
 #include "BundleLoader.h"
 #include <Foundation/Foundation.h>
+#include <mach-o/dyld.h>
+#include <stdlib.h>
 
 // Check if Resources/app/ exists, then load package.json["main"] || app/index.js full file path
 
-std::string resolveMainPath() {
+static NSString* resourcesPathForExecutable(NSString* executablePath) {
+  if (executablePath == nil || [executablePath length] == 0) {
+    return nil;
+  }
+
+  NSString* standardizedPath = [executablePath stringByStandardizingPath];
+  NSString* macOSPath = [standardizedPath stringByDeletingLastPathComponent];
+  NSString* contentsPath = [macOSPath stringByDeletingLastPathComponent];
+  if ([[macOSPath lastPathComponent] isEqualToString:@"MacOS"] &&
+      [[contentsPath lastPathComponent] isEqualToString:@"Contents"]) {
+    return [contentsPath stringByAppendingPathComponent:@"Resources"];
+  }
+
+  return nil;
+}
+
+static bool shouldLogBundleResolution() {
+  return getenv("NS_BUNDLE_LOADER_DEBUG") != nullptr;
+}
+
+static void addCandidatePath(NSMutableArray<NSString*>* candidates, NSString* path) {
+  if (path == nil || [path length] == 0) {
+    return;
+  }
+
+  NSString* standardizedPath = [path stringByStandardizingPath];
+  if (![candidates containsObject:standardizedPath]) {
+    [candidates addObject:standardizedPath];
+  }
+}
+
+static std::string resolveMainPathInResources(NSString* resourcesPath) {
   NSFileManager* fileManager = [NSFileManager defaultManager];
-  NSString* resourcesPath = [[NSBundle mainBundle] resourcePath];
   NSString* appPath = [resourcesPath stringByAppendingPathComponent:@"app"];
   BOOL isDir;
 
   if ([fileManager fileExistsAtPath:appPath isDirectory:&isDir] && isDir) {
+    if (shouldLogBundleResolution()) {
+      NSLog(@"NativeScript BundleLoader checking app path: %@", appPath);
+    }
     NSString* packageJsonPath = [appPath stringByAppendingPathComponent:@"package.json"];
     if ([fileManager fileExistsAtPath:packageJsonPath]) {
       NSData* jsonData = [NSData dataWithContentsOfFile:packageJsonPath];
-      NSError* error;
+      NSError* error = nil;
       NSDictionary* packageDict = [NSJSONSerialization JSONObjectWithData:jsonData
                                                                   options:0
                                                                     error:&error];
       if (error == nil) {
         NSString* mainEntry = packageDict[@"main"];
+        if (shouldLogBundleResolution()) {
+          NSLog(@"NativeScript BundleLoader package main: %@ from %@", mainEntry, packageJsonPath);
+        }
         if (mainEntry != nil) {
           NSString* mainPath = [appPath stringByAppendingPathComponent:mainEntry];
           if ([fileManager fileExistsAtPath:mainPath]) {
+            if (shouldLogBundleResolution()) {
+              NSLog(@"NativeScript BundleLoader resolved main: %@", mainPath);
+            }
             return std::string([mainPath UTF8String]);
           }
 
           if ([[mainEntry pathExtension] length] == 0) {
             NSString* mainPathMjs = [mainPath stringByAppendingPathExtension:@"mjs"];
             if ([fileManager fileExistsAtPath:mainPathMjs]) {
+              if (shouldLogBundleResolution()) {
+                NSLog(@"NativeScript BundleLoader resolved main: %@", mainPathMjs);
+              }
               return std::string([mainPathMjs UTF8String]);
             }
 
             NSString* mainPathJs = [mainPath stringByAppendingPathExtension:@"js"];
             if ([fileManager fileExistsAtPath:mainPathJs]) {
+              if (shouldLogBundleResolution()) {
+                NSLog(@"NativeScript BundleLoader resolved main: %@", mainPathJs);
+              }
               return std::string([mainPathJs UTF8String]);
             }
           }
         }
+      } else if (shouldLogBundleResolution()) {
+        NSLog(@"NativeScript BundleLoader failed to parse %@: %@", packageJsonPath, error);
       }
     }
 
     // Fallback to app/index.js
     NSString* indexPath = [appPath stringByAppendingPathComponent:@"index.js"];
     if ([fileManager fileExistsAtPath:indexPath]) {
+      if (shouldLogBundleResolution()) {
+        NSLog(@"NativeScript BundleLoader resolved fallback main: %@", indexPath);
+      }
       return std::string([indexPath UTF8String]);
     }
+  } else if (shouldLogBundleResolution()) {
+    NSLog(@"NativeScript BundleLoader skipped resources path: %@ appPath=%@ exists=%d isDir=%d",
+          resourcesPath,
+          appPath,
+          [fileManager fileExistsAtPath:appPath],
+          isDir);
+  }
+
+  return "";
+}
+
+std::string resolveMainPath() {
+  NSMutableArray<NSString*>* candidates = [NSMutableArray array];
+  addCandidatePath(candidates, [[NSBundle mainBundle] resourcePath]);
+  addCandidatePath(candidates, resourcesPathForExecutable([[NSBundle mainBundle] executablePath]));
+
+  NSArray<NSString*>* arguments = [[NSProcessInfo processInfo] arguments];
+  if ([arguments count] > 0) {
+    addCandidatePath(candidates, resourcesPathForExecutable([arguments objectAtIndex:0]));
+  }
+
+  uint32_t executablePathLength = 0;
+  _NSGetExecutablePath(nullptr, &executablePathLength);
+  if (executablePathLength > 0) {
+    char* executablePathBuffer = static_cast<char*>(malloc(executablePathLength));
+    if (executablePathBuffer != nullptr) {
+      if (_NSGetExecutablePath(executablePathBuffer, &executablePathLength) == 0) {
+        addCandidatePath(candidates, resourcesPathForExecutable([NSString stringWithUTF8String:executablePathBuffer]));
+      }
+      free(executablePathBuffer);
+    }
+  }
+
+  NSString* currentDirectory = [[NSFileManager defaultManager] currentDirectoryPath];
+  addCandidatePath(candidates, currentDirectory);
+  addCandidatePath(candidates, [currentDirectory stringByAppendingPathComponent:@"Resources"]);
+  addCandidatePath(candidates, [[currentDirectory stringByDeletingLastPathComponent] stringByAppendingPathComponent:@"Resources"]);
+
+  for (NSString* resourcesPath in candidates) {
+    if (shouldLogBundleResolution()) {
+      NSLog(@"NativeScript BundleLoader candidate resources: %@", resourcesPath);
+    }
+    std::string mainPath = resolveMainPathInResources(resourcesPath);
+    if (!mainPath.empty()) {
+      return mainPath;
+    }
   }
 
   return "";

NativeScript/ffi/hermes/NativeApiJsi.mm

@@ -175,6 +175,13 @@ throw JSError(runtime,
 
         const bool propertyGetterCall =
             entry.hasMember && entry.member.property && count == 0;
+        if (propertyGetterCall) {
+          Value appearanceExpando = cachedAppearanceProxyPropertyValue(
+              runtime, bridge, receiver, entry.member.name);
+          if (!appearanceExpando.isUndefined()) {
+            return appearanceExpando;
+          }
+        }
         const std::string* selectorNamePtr = &entry.selectorName;
         const NativeApiMember* selectedMember =
             entry.hasMember ? &entry.member : nullptr;
@@ -260,12 +267,15 @@ throw JSError(runtime,
         // disown handling, or implicit NSError-out argument).
         if (prepared->gsdEngineCallable && gsdDispatchClass == Nil &&
             count == prepared->gsdEngineArgumentCount &&
-            !(!receiverIsClass && prepared->isInitMethod)) {
+            !(!receiverIsClass && prepared->isInitMethod) &&
+            !isPreparedStaticAppearanceSelector(*prepared)) {
           auto invoker =
               reinterpret_cast<ObjCGsdInvoker>(prepared->engineInvoker);
           GsdObjCContext ctx{runtime, bridge, receiver, prepared->selector,
                              args, prepared->signature.returnType};
           if (invoker(ctx)) {
+            cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                                    *prepared, args, count);
             return std::move(ctx.result);
           }
         }
@@ -293,8 +303,15 @@ throw JSError(runtime,
           throw JSError(runtime,
                         "Objective-C selector requires a native receiver.");
         }
-        return receiverHostObject->callPreparedObjectSelector(
+        Value result = receiverHostObject->callPreparedObjectSelector(
             runtime, *prepared, args, count, gsdDispatchClass);
+        if (!receiverIsClass && prepared->isInitMethod) {
+          if (auto preserved = preservedNativeApiInitializerSelfReturn(
+                  runtime, bridge, receiver, result, thisValue)) {
+            return *preserved;
+          }
+        }
+        return result;
       });
 }
 

NativeScript/ffi/hermes/NativeApiJsiReactNative.h

@@ -62,7 +62,8 @@ inline NativeApiJsiConfig MakeReactNativeNativeApiJsiConfig(
   config.metadataPath = metadataPath;
   config.metadataPtr = metadataPtr;
   config.globalName = globalName;
-  config.installGlobalSymbols = true;
+  config.installGlobalSymbols = false;
+  config.indexRuntimePointers = false;
   config.invokeCallbacksOnNativeCallerThread = true;
   config.scheduler = std::make_shared<ReactNativeCallInvokerScheduler>(
       std::move(jsInvoker), std::move(uiInvoker));

NativeScript/ffi/jsc/NativeApiJSCSelectorGroups.mm

@@ -106,11 +106,17 @@ throw JSError(
   // return value — bypassing all generic marshalling.
   if (prepared.gsdEngineCallable && dispatchSuperClass == Nil &&
       providedCount == prepared.gsdEngineArgumentCount &&
-      !initializerClassWrapper && !isNSErrorOutMethod) {
+      !initializerClassWrapper && !isNSErrorOutMethod &&
+      !isPreparedStaticAppearanceSelector(prepared)) {
     auto invoker = reinterpret_cast<ObjCGsdInvoker>(prepared.engineInvoker);
     GsdObjCContext ctx{runtime,  bridge,    receiver, prepared.selector,
                        runtime.context(), arguments, signature.returnType};
     if (invoker(ctx)) {
+      if (providedCount > 0) {
+        Value setterValue = Value::borrowed(runtime, arguments[0]);
+        cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                                prepared, &setterValue, 1);
+      }
       return ctx.result;
     }
   }
@@ -125,6 +131,11 @@ throw JSError(
     if (tryCallFastEngineObjCSelector(runtime, bridge, receiver, prepared,
                                       fastArgs, providedCount, Nil,
                                       &fastResult)) {
+      cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                              prepared, fastArgs,
+                                              providedCount);
+      fastResult = tagPreparedStaticAppearanceSelectorResult(
+          runtime, bridge, receiver, prepared, std::move(fastResult));
       return fastResult.local(runtime);
     }
   }
@@ -195,6 +206,11 @@ NativeApiReturnStorage returnStorage(
     throw JSError(
         runtime, errorMessage != nullptr ? errorMessage : "Unknown NSError");
   }
+  if (providedCount > 0) {
+    Value setterValue = Value::borrowed(runtime, arguments[0]);
+    cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                            prepared, &setterValue, 1);
+  }
   if (initializerClassWrapper) {
     id resultObject = nil;
     if (isObjectiveCObjectType(returnType)) {
@@ -209,6 +225,8 @@ throw JSError(
                                Value(runtime, *initializerClassWrapper));
     }
   }
+  tagPreparedStaticAppearanceNativeReturn(
+      runtime, bridge, receiver, prepared, returnType, returnStorage.data());
   return setJSCEngineReturnValue(runtime, bridge, returnType,
                                  returnStorage.data(), prepared.selectorName);
 }
@@ -265,6 +283,13 @@ throw JSError(runtime,
 
     const bool propertyGetterCall =
         entry.hasMember && entry.member.property && argumentCount == 0;
+    if (propertyGetterCall) {
+      Value appearanceExpando = cachedAppearanceProxyPropertyValue(
+          runtime, data->bridge, receiver, entry.member.name);
+      if (!appearanceExpando.isUndefined()) {
+        return appearanceExpando.local(runtime);
+      }
+    }
     const std::string* selectorNamePtr = &entry.selectorName;
     const NativeApiMember* selectedMember =
         entry.hasMember ? &entry.member : nullptr;
@@ -373,9 +398,18 @@ throw JSError(runtime,
         data->cachedDispatchClass = dispatchClass;
       }
     }
-    return setJSCEnginePreparedObjCResult(
+    JSValueRef result = setJSCEnginePreparedObjCResult(
         runtime, data->bridge, receiver, *prepared, receiverHostObject,
         initializerClassWrapper, argumentCount, arguments, dispatchClass);
+    if (!data->receiverIsClass && prepared->isInitMethod &&
+        thisObject != nullptr) {
+      if (auto preserved = preservedNativeApiInitializerSelfReturn(
+              runtime, data->bridge, receiver, Value::borrowed(runtime, result),
+              Value::borrowed(runtime, thisObject))) {
+        return preserved->local(runtime);
+      }
+    }
+    return result;
   } catch (const std::exception& error) {
     engine::jscengine::setException(context, exception, error);
     return JSValueMakeUndefined(context);

NativeScript/ffi/quickjs/NativeApiQuickJSSelectorGroups.mm

@@ -105,11 +105,17 @@ throw JSError(
   // return value — bypassing all generic marshalling.
   if (prepared.gsdEngineCallable && dispatchSuperClass == Nil &&
       providedCount == prepared.gsdEngineArgumentCount &&
-      !initializerClassWrapper && !isNSErrorOutMethod) {
+      !initializerClassWrapper && !isNSErrorOutMethod &&
+      !isPreparedStaticAppearanceSelector(prepared)) {
     auto invoker = reinterpret_cast<ObjCGsdInvoker>(prepared.engineInvoker);
     GsdObjCContext ctx{runtime,           bridge,    receiver, prepared.selector,
                        runtime.context(), arguments, signature.returnType};
     if (invoker(ctx)) {
+      if (providedCount > 0) {
+        Value setterValue = Value::borrowed(runtime, arguments[0]);
+        cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                                prepared, &setterValue, 1);
+      }
       return ctx.result;
     }
   }
@@ -124,6 +130,11 @@ throw JSError(
     if (tryCallFastEngineObjCSelector(runtime, bridge, receiver, prepared,
                                       fastArgs, providedCount, Nil,
                                       &fastResult)) {
+      cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                              prepared, fastArgs,
+                                              providedCount);
+      fastResult = tagPreparedStaticAppearanceSelectorResult(
+          runtime, bridge, receiver, prepared, std::move(fastResult));
       return fastResult.local(runtime);
     }
   }
@@ -195,6 +206,11 @@ NativeApiReturnStorage returnStorage(
     throw JSError(
         runtime, errorMessage != nullptr ? errorMessage : "Unknown NSError");
   }
+  if (providedCount > 0) {
+    Value setterValue = Value::borrowed(runtime, arguments[0]);
+    cachePreparedAppearanceProxySetterValue(runtime, bridge, receiver,
+                                            prepared, &setterValue, 1);
+  }
   if (initializerClassWrapper) {
     id resultObject = nil;
     if (isObjectiveCObjectType(returnType)) {
@@ -209,6 +225,8 @@ throw JSError(
                                Value(runtime, *initializerClassWrapper));
     }
   }
+  tagPreparedStaticAppearanceNativeReturn(
+      runtime, bridge, receiver, prepared, returnType, returnStorage.data());
   return setQuickJSEngineReturnValue(runtime, bridge, returnType,
                                      returnStorage.data(),
                                      prepared.selectorName);
@@ -287,6 +305,13 @@ throw JSError(runtime,
 
     const bool propertyGetterCall =
         entry.hasMember && entry.member.property && count == 0;
+    if (propertyGetterCall) {
+      Value appearanceExpando = cachedAppearanceProxyPropertyValue(
+          runtime, data->bridge, receiver, entry.member.name);
+      if (!appearanceExpando.isUndefined()) {
+        return appearanceExpando.local(runtime);
+      }
+    }
     const std::string* selectorNamePtr = &entry.selectorName;
     const NativeApiMember* selectedMember =
         entry.hasMember ? &entry.member : nullptr;
@@ -386,9 +411,18 @@ throw JSError(runtime,
         data->cachedDispatchClass = dispatchClass;
       }
     }
-    return setQuickJSEnginePreparedObjCResult(
+    JSValue result = setQuickJSEnginePreparedObjCResult(
         runtime, data->bridge, receiver, *prepared, receiverHostObject,
         initializerClassWrapper, count, argv, dispatchClass);
+    if (!data->receiverIsClass && prepared->isInitMethod) {
+      if (auto preserved = preservedNativeApiInitializerSelfReturn(
+              runtime, data->bridge, receiver, Value::borrowed(runtime, result),
+              Value::borrowed(runtime, thisValue))) {
+        JS_FreeValue(context, result);
+        return preserved->local(runtime);
+      }
+    }
+    return result;
   } catch (const std::exception& error) {
     return engine::quickjsengine::throwError(context, error);
   }