implement more compat

DjDeveloperr · DjDeveloperr · commit 3b593dc3f3ff · 2025-09-16T18:20:15.000-04:00
- Date to NSDate conversion
- implicit constructor calling (new NSObject -&gt; NSObject.new(), and parametered constructors matching as well)
- return null properly on native-&gt;JS conversions
diff --git a/NativeScript/ffi/Class.mm b/NativeScript/ffi/Class.mm
@@ -195,7 +195,25 @@ void setupObjCClassDecorator(napi_env env) {
 }
 
 NAPI_FUNCTION(BridgedConstructor) {
-  NAPI_CALLBACK_BEGIN(0)
+  NAPI_CALLBACK_BEGIN(1)
+
+  napi_valuetype jsType;
+  napi_typeof(env, argv[0], &jsType);
+
+  id object = nil;
+
+  if (jsType == napi_external) {
+    return jsThis;
+  } else {
+    Class cls = (Class)data;
+    object = [cls new];
+
+    ObjCBridgeState* bridgeState = ObjCBridgeState::InstanceData(env);
+    jsThis = bridgeState->proxyNativeObject(env, jsThis, object);
+  }
+
+  napi_wrap(env, jsThis, object, nullptr, nullptr, nullptr);
+
   return jsThis;
 }
 
@@ -390,7 +408,8 @@ napi_value toJS(napi_env env) {
 // extended by a JS class.
 // Every Bridged Class extends the NativeObject class.
 
-void defineProtocolMembers(napi_env env, ObjCClassMemberMap& members, napi_value constructor, ObjCProtocol* protocol) {
+void defineProtocolMembers(napi_env env, ObjCClassMemberMap& members, napi_value constructor,
+                           ObjCProtocol* protocol) {
   ObjCClassMember::defineMembers(env, members, protocol->membersOffset, constructor);
   for (auto protocol : protocol->protocols) {
     defineProtocolMembers(env, members, constructor, protocol);
@@ -443,11 +462,12 @@ void defineProtocolMembers(napi_env env, ObjCClassMemberMap& members, napi_value
 
   napi_value constructor, prototype;
 
-  napi_define_class(env, name.c_str(), name.length(), JS_BridgedConstructor, (void*)this, 0, nil,
-                    &constructor);
+  napi_define_class(env, name.c_str(), name.length(), JS_BridgedConstructor, (void*)nativeClass, 0,
+                    nil, &constructor);
 
   if (nativeClass != nil) {
     napi_wrap(env, constructor, (void*)nativeClass, nil, nil, nil);
+    bridgeState->classesByPointer[nativeClass] = this;
   }
 
   napi_get_named_property(env, constructor, "prototype", &prototype);
@@ -552,18 +572,17 @@ void defineProtocolMembers(napi_env env, ObjCClassMemberMap& members, napi_value
     return;
   }
 
-  bridgeState->classesByPointer[nativeClass] = this;
-
   // Add the 'extend' static method to all native classes (not NativeObject)
   if (!isNativeObject) {
     napi_value extendMethod;
-    napi_create_function(env, "extend", NAPI_AUTO_LENGTH, ClassBuilder::ExtendCallback, nullptr, &extendMethod);
+    napi_create_function(env, "extend", NAPI_AUTO_LENGTH, ClassBuilder::ExtendCallback, nullptr,
+                         &extendMethod);
     napi_set_named_property(env, constructor, "extend", extendMethod);
   }
 
   if (!hasMembers) return;
 
-  ObjCClassMember::defineMembers(env, members, offset, constructor);
+  ObjCClassMember::defineMembers(env, members, offset, constructor, this);
 }
 
 ObjCClass::~ObjCClass() {
diff --git a/NativeScript/ffi/ClassMember.h b/NativeScript/ffi/ClassMember.h
@@ -47,10 +47,13 @@ class ObjCClassMember;
 
 typedef std::unordered_map<std::string, ObjCClassMember> ObjCClassMemberMap;
 
+class ObjCClass;
+
 class ObjCClassMember {
  public:
   static void defineMembers(napi_env env, ObjCClassMemberMap& memberMap,
-                            MDSectionOffset offset, napi_value constructor);
+                            MDSectionOffset offset, napi_value constructor,
+                            ObjCClass* cls = nullptr);
 
   static napi_value jsCall(napi_env env, napi_callback_info cbinfo);
   static napi_value jsCallInit(napi_env env, napi_callback_info cbinfo);
@@ -83,6 +86,7 @@ class ObjCClassMember {
   Cif* setterCif = nullptr;
   bool returnOwned;
   bool classMethod;
+  ObjCClass* cls;
 };
 
 }  // namespace nativescript
diff --git a/NativeScript/ffi/ClassMember.mm b/NativeScript/ffi/ClassMember.mm
@@ -8,6 +8,7 @@
 #include "ObjCBridge.h"
 #include "TypeConv.h"
 #include "Util.h"
+#include "ffi/Class.h"
 #include "ffi/NativeScriptException.h"
 #include "js_native_api.h"
 #include "js_native_api_types.h"
@@ -35,7 +36,8 @@ napi_value JS_NSObject_alloc(napi_env env, napi_callback_info cbinfo) {
 }
 
 void ObjCClassMember::defineMembers(napi_env env, ObjCClassMemberMap& memberMap,
-                                    MDSectionOffset offset, napi_value constructor) {
+                                    MDSectionOffset offset, napi_value constructor,
+                                    ObjCClass* cls) {
   auto bridgeState = ObjCBridgeState::InstanceData(env);
 
   napi_value prototype;
@@ -115,7 +117,7 @@ napi_value JS_NSObject_alloc(napi_env env, napi_callback_info cbinfo) {
 
       bool hasProperty = false;
       napi_has_named_property(env, jsObject, name.c_str(), &hasProperty);
-      if (hasProperty) {
+      if (hasProperty && name != "init") {
         continue;
       }
 
@@ -135,6 +137,10 @@ napi_value JS_NSObject_alloc(napi_env env, napi_callback_info cbinfo) {
           .data = &kv.first->second,
       };
 
+      if ((flags & mdMemberIsInit) != 0) {
+        kv.first->second.cls = cls;
+      }
+
       if (name == "alloc") {
         property.method = JS_NSObject_alloc;
       }
@@ -198,6 +204,144 @@ inline bool objcNativeCall(napi_env env, Cif* cif, id self, void** avalues, void
   return true;
 }
 
+// Utility function to check if a JS value can be converted to a specific type
+bool canConvertToType(napi_env env, napi_value value, std::shared_ptr<TypeConv> typeConv) {
+  if (value == nullptr) {
+    return true;  // null/undefined can convert to most types
+  }
+
+  napi_valuetype jsType;
+  napi_typeof(env, value, &jsType);
+
+  if (jsType == napi_null || jsType == napi_undefined) {
+    return true;  // null/undefined are generally acceptable
+  }
+
+  // Check basic type compatibility based on TypeConv kind
+  switch (typeConv->kind) {
+    case mdTypeBool:
+      return jsType == napi_boolean || jsType == napi_number;
+
+    case mdTypeChar:
+    case mdTypeUChar:
+    case mdTypeSShort:
+    case mdTypeUShort:
+    case mdTypeSInt:
+    case mdTypeUInt:
+    case mdTypeSLong:
+    case mdTypeULong:
+    case mdTypeSInt64:
+    case mdTypeUInt64:
+    case mdTypeFloat:
+    case mdTypeDouble:
+      return jsType == napi_number || jsType == napi_bigint;
+
+    case mdTypeInstanceObject:
+    case mdTypeNSStringObject:
+    case mdTypeNSMutableStringObject: {
+      if (jsType == napi_string) {
+        // String can convert to NSString
+        return true;
+      }
+      if (jsType == napi_object) {
+        bool isArray;
+        napi_is_array(env, value, &isArray);
+        if (isArray) {
+          // Array can convert to NSArray
+          return true;
+        }
+        // Check if it's a wrapped native object
+        void* wrapped;
+        napi_status status = napi_unwrap(env, value, &wrapped);
+        return status == napi_ok;
+      }
+      return false;
+    }
+
+    case mdTypeSelector:
+      return jsType == napi_string;
+
+    case mdTypePointer:
+    case mdTypeOpaquePointer:
+      return jsType == napi_object || jsType == napi_bigint || jsType == napi_string;
+
+    case mdTypeStruct:
+      return jsType == napi_object;
+
+    case mdTypeBlock:
+      return jsType == napi_function;
+
+    default:
+      return true;  // For unknown types, assume compatible
+  }
+}
+
+// Find the best initializer for a class given JS arguments
+ObjCClassMember* findInitializerForArgs(napi_env env, ObjCClassMemberMap* initializers, size_t argc,
+                                        napi_value* argv) {
+  std::vector<ObjCClassMember*> candidates;
+
+  // First pass: find initializers with matching argument count
+  for (auto& pair : *initializers) {
+    auto* candidate = &pair.second;
+    const char* name = sel_getName(candidate->methodOrGetter.selector);
+    // NSLog(@"Checking initializer: %s", name);
+    if (name[0] != 'i' || name[1] != 'n' || name[2] != 'i' || name[3] != 't') {
+      continue;
+    }
+    Cif* cif = candidate->cif;
+    if (!cif) {
+      // Need to get the CIF to check argument count
+      cif = const_cast<ObjCClassMember*>(candidate)->bridgeState->getMethodCif(
+          env, candidate->methodOrGetter.signatureOffset);
+    }
+
+    // Match argument count (cif->argc excludes self and selector)
+    if (cif->argc == argc) {
+      bool canInvoke = true;
+
+      // Check if all arguments can be converted to the expected types
+      for (size_t i = 0; i < argc; ++i) {
+        if (!canConvertToType(env, argv[i], cif->argTypes[i])) {
+          canInvoke = false;
+          break;
+        }
+      }
+
+      if (canInvoke) {
+        candidates.push_back(candidate);
+      }
+    }
+  }
+
+  if (candidates.empty()) {
+    napi_throw_error(env, "NativeScriptException",
+                     "No initializer found that matches constructor invocation.");
+    return nullptr;
+  } else if (candidates.size() > 1) {
+    // Prefer "init" if no arguments
+    if (argc == 0) {
+      for (auto* candidate : candidates) {
+        const char* selectorName = sel_getName(candidate->methodOrGetter.selector);
+        if (strcmp(selectorName, "init") == 0) {
+          return candidate;
+        }
+      }
+    }
+
+    // If multiple candidates, throw an error with details
+    std::string errorMsg = "More than one initializer found that matches constructor invocation:";
+    for (const auto* candidate : candidates) {
+      errorMsg += " ";
+      errorMsg += sel_getName(candidate->methodOrGetter.selector);
+    }
+    napi_throw_error(env, "NativeScriptException", errorMsg.c_str());
+    return nullptr;
+  }
+
+  return candidates[0];
+}
+
 inline id assertSelf(napi_env env, napi_value jsThis) {
   id self;
   napi_unwrap(env, jsThis, (void**)&self);
@@ -216,21 +360,37 @@ inline id assertSelf(napi_env env, napi_value jsThis) {
   napi_value jsThis;
   ObjCClassMember* method;
 
-  napi_get_cb_info(env, cbinfo, nullptr, nullptr, &jsThis, (void**)&method);
+  size_t argc = 0;
+  napi_get_cb_info(env, cbinfo, &argc, nullptr, &jsThis, (void**)&method);
 
   id self = assertSelf(env, jsThis);
 
   if (self == nullptr) {
     return nullptr;
   }
 
+  SEL sel = method->methodOrGetter.selector;
+  if (sel == @selector(init) && argc > 0) {
+    napi_value argv[argc];
+    napi_get_cb_info(env, cbinfo, &argc, argv, &jsThis, nullptr);
+    Class nativeClass = [self class];
+    ObjCBridgeState* state = ObjCBridgeState::InstanceData(env);
+    ObjCClass* cls = state->classesByPointer[nativeClass];
+    // NSLog(@"find init for class: %@, cls: %p", nativeClass, cls);
+    ObjCClassMember* newMethod = findInitializerForArgs(env, &cls->members, argc, argv);
+    // NSLog(@"new init: %p", newMethod);
+    if (newMethod != nullptr) {
+      method = newMethod;
+    }
+  }
+
   Cif* cif = method->cif;
   if (cif == nullptr) {
     cif = method->cif =
         method->bridgeState->getMethodCif(env, method->methodOrGetter.signatureOffset);
   }
 
-  size_t argc = cif->argc;
+  argc = cif->argc;
   napi_get_cb_info(env, cbinfo, &argc, cif->argv, &jsThis, nullptr);
 
   void* avalues[cif->cif.nargs];
diff --git a/NativeScript/ffi/Object.mm b/NativeScript/ffi/Object.mm
@@ -168,16 +168,16 @@ void finalize_objc_object(napi_env /*env*/, void* data, void* hint) {
   if (isClass) {
     result = constructor;
   } else {
-    NAPI_GUARD(napi_new_instance(env, constructor, 0, nullptr, &result)) {
-      NAPI_THROW_LAST_ERROR
-      return nullptr;
-    }
+    napi_value ext;
+    napi_create_external(env, nullptr, nullptr, nullptr, &ext);
 
-    NAPI_GUARD(napi_wrap(env, result, obj, nullptr, nullptr, nullptr)) {
+    NAPI_GUARD(napi_new_instance(env, constructor, 1, &ext, &result)) {
       NAPI_THROW_LAST_ERROR
       return nullptr;
     }
 
+    napi_wrap(env, result, obj, nullptr, nullptr, nullptr);
+
     if (ownership == kUnownedObject) {
       [obj retain];
     }
diff --git a/NativeScript/ffi/TypeConv.mm b/NativeScript/ffi/TypeConv.mm
