Enhance NativeScript FFI with improved type conversions and compatibility features

- Added support for handling C strings as references in TypeConv.
- Improved SInt64 and UInt64 type conversions to handle large integers using BigInt.
- Enhanced PointerTypeConv to allow for void pointers and improved handling of struct types.
- Introduced new utility functions for managing struct encodings and type definitions.
- Implemented compatibility shims for UIColor on macOS to ensure consistent behavior.
- Updated timer management in Timers.mm to use mutexes for thread safety and prevent memory leaks.
- Enabled reference tests in the TestRunner to ensure proper functionality of reference types.

Author: DjDeveloperr

NativeScript/ffi/CFunction.mm

@@ -81,14 +81,14 @@
 
 #ifdef ENABLE_JS_RUNTIME
   if (strcmp(name, "UIApplicationMain") == 0 || strcmp(name, "NSApplicationMain") == 0) {
-    void **avaluesPtr = new void*[cif->argc];
+    void** avaluesPtr = new void*[cif->argc];
     memcpy(avaluesPtr, avalues, cif->argc * sizeof(void*));
 
     Tasks::Register([env, cif, func, rvalue, avaluesPtr]() {
-      void * avalues[cif->argc];
+      void* avalues[cif->argc];
       memcpy(avalues, avaluesPtr, cif->argc * sizeof(void*));
       delete[] avaluesPtr;
-      
+
       @try {
         ffi_call(&cif->cif, FFI_FN(func->fnptr), rvalue, avalues);
       } @catch (NSException* exception) {
@@ -99,7 +99,7 @@
         nativeScriptException.ReThrowToJS(env);
       }
     });
-    
+
     return nullptr;
   }
 #endif
@@ -115,14 +115,26 @@
   }
 
   if (shouldFreeAny) {
+    void* returnPointerValue = nullptr;
+    bool returnIsPointer = cif->returnType != nullptr && cif->returnType->type == &ffi_type_pointer;
+    if (returnIsPointer && rvalue != nullptr) {
+      returnPointerValue = *((void**)rvalue);
+    }
+
     for (unsigned int i = 0; i < cif->argc; i++) {
       if (shouldFree[i]) {
+        if (returnPointerValue != nullptr && avalues[i] != nullptr) {
+          void* argPointerValue = *((void**)avalues[i]);
+          if (argPointerValue == returnPointerValue) {
+            continue;
+          }
+        }
         cif->argTypes[i]->free(env, *((void**)avalues[i]));
       }
     }
   }
 
-  return cif->returnType->toJS(env, rvalue);
+  return cif->returnType->toJS(env, rvalue, kCStringAsReference);
 }
 
 CFunction::~CFunction() { cif = nullptr; }

NativeScript/ffi/Cif.mm

@@ -100,7 +100,7 @@
     const char* argenc = [signature getArgumentTypeAtIndex:i];
 
     auto argTypeInfo = TypeConv::Make(env, &argenc);
-    this->atypes[i] = argTypeInfo->type;
+    this->atypes[i] = argTypeInfo->ffiTypeForArgument();
 
     if (i >= skippedArgs) {
       this->argTypes.push_back(argTypeInfo);
@@ -162,7 +162,7 @@
       free(argEnc);
     }
 
-    this->atypes[i] = argTypeInfo->type;
+    this->atypes[i] = argTypeInfo->ffiTypeForArgument();
     if (i >= 2) {
       this->argTypes.push_back(argTypeInfo);
     }
@@ -226,7 +226,7 @@
     }
 
     for (int i = 0; i < argc; i++) {
-      atypes[i + implicitArgs] = argTypes[i]->type;
+      atypes[i + implicitArgs] = argTypes[i]->ffiTypeForArgument();
       shouldFree[i] = false;
     }
   } else {

NativeScript/ffi/Class.mm

@@ -1,6 +1,7 @@
 #include "Class.h"
 #include "ClassBuilder.h"
 #include "ClassMember.h"
+#include "Interop.h"
 #include "Metadata.h"
 #include "MetadataReader.h"
 #include "ObjCBridge.h"
@@ -18,6 +19,49 @@
 
 napi_value JS_NSObject_alloc(napi_env env, napi_callback_info cbinfo);
 
+inline bool tryGetInteropPointerArg(napi_env env, napi_value value, void** out) {
+  if (out == nullptr || value == nullptr) {
+    return false;
+  }
+
+  *out = nullptr;
+
+  napi_valuetype argType = napi_undefined;
+  napi_typeof(env, value, &argType);
+
+  if (argType == napi_external) {
+    return napi_get_value_external(env, value, out) == napi_ok && *out != nullptr;
+  }
+
+  if (argType == napi_bigint) {
+    uint64_t raw = 0;
+    bool lossless = false;
+    if (napi_get_value_bigint_uint64(env, value, &raw, &lossless) != napi_ok) {
+      return false;
+    }
+    *out = reinterpret_cast<void*>(raw);
+    return *out != nullptr;
+  }
+
+  if (argType != napi_object) {
+    return false;
+  }
+
+  if (Pointer::isInstance(env, value)) {
+    Pointer* ptr = Pointer::unwrap(env, value);
+    *out = ptr != nullptr ? ptr->data : nullptr;
+    return *out != nullptr;
+  }
+
+  if (Reference::isInstance(env, value)) {
+    Reference* ref = Reference::unwrap(env, value);
+    *out = ref != nullptr ? ref->data : nullptr;
+    return *out != nullptr;
+  }
+
+  return false;
+}
+
 void ObjCBridgeState::registerClassGlobals(napi_env env, napi_value global) {
   MDSectionOffset offset = metadata->classesOffset;
   while (offset < metadata->structsOffset) {
@@ -255,6 +299,27 @@ void setupObjCClassDecorator(napi_env env) {
   if (jsType == napi_external) {
     return jsThis;
   } else {
+    // Backward compatibility: allow `new Class(pointer)` to wrap an existing
+    // native instance instead of running initializer resolution.
+    if (argc == 1 && argv[0] != nullptr) {
+      void* rawPointer = nullptr;
+      if (tryGetInteropPointerArg(env, argv[0], &rawPointer) && rawPointer != nullptr) {
+        object = (id)rawPointer;
+        napi_value constructor = nullptr;
+        if (napi_get_named_property(env, jsThis, "constructor", &constructor) == napi_ok &&
+            constructor != nullptr) {
+          napi_value existing = bridgeState->getObject(env, object, constructor, kUnownedObject);
+          if (existing != nullptr) {
+            return existing;
+          }
+        }
+
+        jsThis = bridgeState->proxyNativeObject(env, jsThis, object);
+        napi_wrap(env, jsThis, object, nullptr, nullptr, nullptr);
+        return jsThis;
+      }
+    }
+
     bool supercall = class_conformsToProtocol(cls, @protocol(ObjCBridgeClassBuilderProtocol));
 
     if (supercall) {

NativeScript/ffi/Closure.mm

@@ -214,7 +214,7 @@ void JSBlockCallback(ffi_cif* cif, void* ret, void* args[], void* data) {
   for (int i = 0; i < argc; i++) {
     const char* argenc = [signature getArgumentTypeAtIndex:i];
     auto argTypeInfo = TypeConv::Make(env, &argenc);
-    this->atypes[i + skipArgs] = argTypeInfo->type;
+    this->atypes[i + skipArgs] = argTypeInfo->ffiTypeForArgument();
     this->argTypes.push_back(argTypeInfo);
   }
 
@@ -228,10 +228,9 @@ void JSBlockCallback(ffi_cif* cif, void* ret, void* args[], void* data) {
 
   closure = (ffi_closure*)ffi_closure_alloc(sizeof(ffi_closure), &fnptr);
 
-  ffi_prep_closure_loc(closure, &cif,
-                       isBlock ? JSBlockCallback
-                               : (isMethod ? JSMethodCallback : JSFunctionCallback),
-                       this, fnptr);
+  ffi_prep_closure_loc(
+      closure, &cif, isBlock ? JSBlockCallback : (isMethod ? JSMethodCallback : JSFunctionCallback),
+      this, fnptr);
 }
 
 Closure::Closure(MDMetadataReader* reader, MDSectionOffset offset, bool isBlock,
@@ -273,7 +272,7 @@ void JSBlockCallback(ffi_cif* cif, void* ret, void* args[], void* data) {
       this->atypes[0] = &ffi_type_pointer;
     }
     for (int i = 0; i < argTypes.size(); i++) {
-      this->atypes[i + skipArgs] = argTypes[i]->type;
+      this->atypes[i + skipArgs] = argTypes[i]->ffiTypeForArgument();
     }
   }
 
@@ -286,10 +285,9 @@ void JSBlockCallback(ffi_cif* cif, void* ret, void* args[], void* data) {
 
   closure = (ffi_closure*)ffi_closure_alloc(sizeof(ffi_closure), &fnptr);
 
-  ffi_prep_closure_loc(closure, &cif,
-                       isBlock ? JSBlockCallback
-                               : (isMethod ? JSMethodCallback : JSFunctionCallback),
-                       this, fnptr);
+  ffi_prep_closure_loc(
+      closure, &cif, isBlock ? JSBlockCallback : (isMethod ? JSMethodCallback : JSFunctionCallback),
+      this, fnptr);
 }
 
 Closure::~Closure() {

NativeScript/ffi/Enum.mm

@@ -1,16 +1,17 @@
 #include "Enum.h"
 #import <Foundation/Foundation.h>
-#include "ObjCBridge.h"
 #include <algorithm>
 #include <cstring>
 #include <unordered_set>
 #include <vector>
+#include "ObjCBridge.h"
 
 namespace nativescript {
 
 namespace {
 inline void defineConstantIfMissing(napi_env env, napi_value object, const std::string& name,
-                                    napi_value value) {
+                                    napi_value value,
+                                    napi_property_attributes attributes = napi_enumerable) {
   bool hasProperty = false;
   napi_has_named_property(env, object, name.c_str(), &hasProperty);
   if (hasProperty) {
@@ -23,7 +24,7 @@ inline void defineConstantIfMissing(napi_env env, napi_value object, const std::
       .getter = nullptr,
       .setter = nullptr,
       .value = value,
-      .attributes = napi_enumerable,
+      .attributes = attributes,
       .data = nullptr,
   };
   napi_define_properties(env, object, 1, &prop);
@@ -35,8 +36,8 @@ inline bool startsWith(const std::string& value, const std::string& prefix) {
 
 inline std::string stripEnumSuffix(const std::string& enumName) {
   static const std::vector<std::string> suffixes = {
-      "Options", "Option", "Enums", "Enum", "Result", "Direction", "Orientation", "Style",
-      "Mask",    "Type",   "Status", "Modes", "Mode", "s"};
+      "Options", "Option", "Enums", "Enum",   "Result", "Direction", "Orientation",
+      "Style",   "Mask",   "Type",  "Status", "Modes",  "Mode",      "s"};
 
   for (const auto& suffix : suffixes) {
     if (enumName.size() > suffix.size() &&
@@ -48,7 +49,8 @@ inline bool startsWith(const std::string& value, const std::string& prefix) {
   return enumName;
 }
 
-inline bool isNSComparisonResultOrderingName(const std::string& enumName, const std::string& member) {
+inline bool isNSComparisonResultOrderingName(const std::string& enumName,
+                                             const std::string& member) {
   if (enumName != "NSComparisonResult") {
     return false;
   }
@@ -75,7 +77,8 @@ inline bool isNSComparisonResultOrderingName(const std::string& enumName, const
 
       napi_value member;
       napi_create_int64(env, value, &member);
-      defineConstantIfMissing(env, global, memberName, member);
+      defineConstantIfMissing(env, global, memberName, member,
+                              (napi_property_attributes)(napi_enumerable | napi_configurable));
     }
 
     napi_property_descriptor prop = {
@@ -169,7 +172,8 @@ inline bool isNSComparisonResultOrderingName(const std::string& enumName, const
 
     for (const auto& alias : uniqueAliases) {
       defineConstantIfMissing(env, result, alias, member);
-      defineConstantIfMissing(env, global, alias, member);
+      defineConstantIfMissing(env, global, alias, member,
+                              (napi_property_attributes)(napi_enumerable | napi_configurable));
     }
 
     std::string reverseCanonical = uniqueAliases.size() > 1 ? uniqueAliases[1] : memberName;