expose micotask checkpoint, add class.extend, fix type conversions

DjDeveloperr · DjDeveloperr · commit 3083d3a8b293 · 2025-08-17T01:24:03.000-04:00
diff --git a/NativeScript/ffi/CFunction.mm b/NativeScript/ffi/CFunction.mm
@@ -3,7 +3,7 @@
 #include "ObjCBridge.h"
 #include "ffi/NativeScriptException.h"
 #include "ffi/Tasks.h"
-#ifdef ENABLE_JS_ENGINE
+#ifdef ENABLE_JS_RUNTIME
 #include "jsr.h"
 #endif
 
@@ -79,7 +79,7 @@
     }
   }
 
-#ifdef ENABLE_JS_ENGINE
+#ifdef ENABLE_JS_RUNTIME
   if (strcmp(name, "UIApplicationMain") == 0 || strcmp(name, "NSApplicationMain") == 0) {
     void **avaluesPtr = new void*[cif->argc];
     memcpy(avaluesPtr, avalues, cif->argc * sizeof(void*));
diff --git a/NativeScript/ffi/Class.mm b/NativeScript/ffi/Class.mm
@@ -554,6 +554,13 @@ void defineProtocolMembers(napi_env env, ObjCClassMemberMap& members, napi_value
 
   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_set_named_property(env, constructor, "extend", extendMethod);
+  }
+
   if (!hasMembers) return;
 
   ObjCClassMember::defineMembers(env, members, offset, constructor);
diff --git a/NativeScript/ffi/ClassBuilder.h b/NativeScript/ffi/ClassBuilder.h
@@ -24,6 +24,9 @@ class ClassBuilder : public ObjCClass {
                  napi_value func = nullptr);
 
   void build();
+  
+  // Static callback for extending native classes
+  static napi_value ExtendCallback(napi_env env, napi_callback_info info);
 
   MethodMap exposedMethods;
   std::unordered_set<ObjCProtocol*> protocols;
diff --git a/NativeScript/ffi/ClassBuilder.mm b/NativeScript/ffi/ClassBuilder.mm
@@ -259,4 +259,110 @@
   }
 }
 
+// Static method to extend native classes with JavaScript-defined methods
+napi_value ClassBuilder::ExtendCallback(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  napi_value thisArg;
+  
+  napi_get_cb_info(env, info, &argc, args, &thisArg, nullptr);
+  
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "extend() requires at least one parameter with method definitions");
+    return nullptr;
+  }
+  
+  // Validate that the first argument is an object
+  napi_valuetype argType;
+  napi_typeof(env, args[0], &argType);
+  if (argType != napi_object) {
+    napi_throw_error(env, nullptr, "extend() first parameter must be an object");
+    return nullptr;
+  }
+  
+  // Get the native class from 'this' (the constructor function)
+  Class baseNativeClass = nullptr;
+  napi_unwrap(env, thisArg, (void**)&baseNativeClass);
+  
+  if (baseNativeClass == nullptr) {
+    napi_throw_error(env, nullptr, "extend() can only be called on native class constructors");
+    return nullptr;
+  }
+  
+  // Create a unique class name
+  napi_value baseClassName;
+  napi_get_named_property(env, thisArg, "name", &baseClassName);
+  static char baseClassNameBuf[512];
+  napi_get_value_string_utf8(env, baseClassName, baseClassNameBuf, 512, nullptr);
+  
+  std::string newClassName = baseClassNameBuf;
+  newClassName += "_Extended_";
+  newClassName += std::to_string(rand());
+  
+  // Create the new constructor function that extends the base
+  napi_value newConstructor;
+  napi_define_class(env, newClassName.c_str(), newClassName.length(), 
+                    [](napi_env env, napi_callback_info info) -> napi_value {
+    // Constructor implementation - delegate to base class
+    napi_value thisArg;
+    napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, nullptr);
+    return thisArg;
+  }, nullptr, 0, nullptr, &newConstructor);
+  
+  // Set up JavaScript inheritance from the base class
+  napi_inherits(env, newConstructor, thisArg);
+  
+  // Get prototype for adding methods
+  napi_value newPrototype;
+  napi_get_named_property(env, newConstructor, "prototype", &newPrototype);
+  
+  // Add methods from the first parameter to the prototype
+  napi_value methodNames;
+  napi_get_all_property_names(env, args[0], napi_key_own_only, napi_key_skip_symbols,
+                              napi_key_numbers_to_strings, &methodNames);
+  
+  uint32_t methodCount = 0;
+  napi_get_array_length(env, methodNames, &methodCount);
+  
+  for (uint32_t i = 0; i < methodCount; i++) {
+    napi_value methodName, methodFunc;
+    napi_get_element(env, methodNames, i, &methodName);
+    
+    static char methodNameBuf[512];
+    napi_get_value_string_utf8(env, methodName, methodNameBuf, 512, nullptr);
+    std::string name = methodNameBuf;
+    
+    napi_get_named_property(env, args[0], name.c_str(), &methodFunc);
+    
+    // Add the method to the prototype
+    napi_set_named_property(env, newPrototype, name.c_str(), methodFunc);
+  }
+  
+  // Handle optional second parameter for protocols
+  if (argc >= 2) {
+    napi_valuetype secondArgType;
+    napi_typeof(env, args[1], &secondArgType);
+    if (secondArgType == napi_object) {
+      napi_value protocols;
+      bool hasProtocols = false;
+      napi_has_named_property(env, args[1], "protocols", &hasProtocols);
+      
+      if (hasProtocols) {
+        napi_get_named_property(env, args[1], "protocols", &protocols);
+        napi_set_named_property(env, newConstructor, "ObjCProtocols", protocols);
+      }
+    }
+  }
+  
+  // Use ClassBuilder to create the native class and bridge the methods
+  ClassBuilder* builder = new ClassBuilder(env, newConstructor);
+  builder->build();
+  
+  // Register the builder in the bridge state
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
+  bridgeState->classesByPointer[builder->nativeClass] = builder;
+  
+  return newConstructor;
+}
+
 }  // namespace nativescript
diff --git a/NativeScript/ffi/Closure.mm b/NativeScript/ffi/Closure.mm
@@ -8,7 +8,7 @@
 #include "ffi/NativeScriptException.h"
 #include "js_native_api.h"
 #include "js_native_api_types.h"
-#ifdef ENABLE_JS_ENGINE
+#ifdef ENABLE_JS_RUNTIME
 #include "jsr.h"
 #endif
 #include "node_api_util.h"
@@ -25,7 +25,7 @@ inline void JSCallbackInner(Closure* closure, napi_value func, napi_value thisAr
                             size_t argc, bool* done, void* ret) {
   napi_env env = closure->env;
 
-#ifdef ENABLE_JS_ENGINE
+#ifdef ENABLE_JS_RUNTIME
   NapiScope scope(env);
 #endif
 
diff --git a/NativeScript/ffi/Interop.mm b/NativeScript/ffi/Interop.mm
@@ -342,6 +342,10 @@ napi_value interop_stringFromCString(napi_env env, napi_callback_info info) {
   napi_valuetype type;
   napi_typeof(env, arg, &type);
 
+  if (type == napi_string) {
+    return arg;
+  }
+
   if (type != napi_object) {
     napi_throw_type_error(env, "TypeError", "Expected an object");
     return nullptr;
diff --git a/NativeScript/ffi/NativeScriptException.mm b/NativeScript/ffi/NativeScriptException.mm
@@ -3,7 +3,7 @@
 #include <sstream>
 #include "js_native_api.h"
 #include "js_native_api_types.h"
-#ifdef ENABLE_JS_ENGINE
+#ifdef ENABLE_JS_RUNTIME
 #include "jsr.h"
 #endif
 #include "native_api_util.h"
@@ -50,7 +50,7 @@
 }
 
 void NativeScriptException::OnUncaughtError(napi_env env, napi_value error) {
-#ifdef ENABLE_JS_ENGINE
+#ifdef ENABLE_JS_RUNTIME
   NapiScope scope(env);
 #endif
 
diff --git a/NativeScript/ffi/TypeConv.mm b/NativeScript/ffi/TypeConv.mm
@@ -910,8 +910,17 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
       }
 
       case napi_object: {
-        FunctionReference* ref = FunctionReference::unwrap(env, value);
-        *res = ref->getFunctionPointer(signatureOffset);
+        if (Pointer::isInstance(env, value)) {
+          Pointer* ptr = Pointer::unwrap(env, value);
+          *res = ptr->data;
+        } else if (Reference::isInstance(env, value)) {
+          Reference* ref = Reference::unwrap(env, value);
+          *res = ref->data;
+        } else {
+          FunctionReference* ref = FunctionReference::unwrap(env, value);
+          *res = ref->getFunctionPointer(signatureOffset);
+        }
+        return;
       }
 
       case napi_function: {
diff --git a/NativeScript/napi/v8/jsr.cpp b/NativeScript/napi/v8/jsr.cpp
@@ -85,6 +85,7 @@ JSR::JSR(): isolate(nullptr) {
 
     if (!JSR::s_mainThreadInitialized) {
         JSR::platform = v8::platform::NewDefaultPlatform().release();
+        v8::V8::SetFlagsFromString("--expose_gc");
         v8::V8::InitializePlatform(JSR::platform);
         v8::V8::Initialize();
         JSR::s_mainThreadInitialized = true;
diff --git a/NativeScript/runtime/Runtime.cpp b/NativeScript/runtime/Runtime.cpp
@@ -60,6 +60,11 @@ Runtime::~Runtime() {
   }
 }
 
+napi_value drainMicrotasks(napi_env env, napi_callback_info cbinfo) {
+  js_execute_pending_jobs(env);
+  return nullptr;
+}
+
 void Runtime::Init(bool isWorker) {
   js_set_runtime_flags("");
 
@@ -118,11 +123,90 @@ void Runtime::Init(bool isWorker) {
   napi_create_string_utf8(env_, CompatScript, NAPI_AUTO_LENGTH, &compatScript);
   napi_run_script(env_, compatScript, &result);
 
+  #ifdef TARGET_ENGINE_V8
+  const char *PromiseProxyScript = R"(
+        // Ensure that Promise callbacks are executed on the
+        // same thread on which they were created
+        (() => {
+            global.Promise = new Proxy(global.Promise, {
+                construct: function(target, args) {
+                    let origFunc = args[0];
+                    let runloop = CFRunLoopGetCurrent();
+
+                    let promise = new target(function(resolve, reject) {
+                        function isFulfilled() {
+                            return !resolve;
+                        }
+                        function markFulfilled() {
+                            origFunc = null;
+                            resolve = null;
+                            reject = null;
+                        }
+                        origFunc(value => {
+                            if (isFulfilled()) {
+                                return;
+                            }
+                            const resolveCall = resolve.bind(this, value);
+                            if (runloop === CFRunLoopGetCurrent()) {
+                                markFulfilled();
+                                resolveCall();
+                            } else {
+                                CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, resolveCall);
+                                CFRunLoopWakeUp(runloop);
+                                markFulfilled();
+                            }
+                        }, reason => {
+                            if (isFulfilled()) {
+                                return;
+                            }
+                            const rejectCall = reject.bind(this, reason);
+                            if (runloop === CFRunLoopGetCurrent()) {
+                                markFulfilled();
+                                rejectCall();
+                            } else {
+                                CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, rejectCall);
+                                CFRunLoopWakeUp(runloop);
+                                markFulfilled();
+                            }
+                        });
+                    });
+
+                    return new Proxy(promise, {
+                        get: function(target, name) {
+                            let orig = target[name];
+                            if (name === "then" || name === "catch" || name === "finally") {
+                                return orig.bind(target);
+                            }
+                            return typeof orig === 'function' ? function(x) {
+                                if (runloop === CFRunLoopGetCurrent()) {
+                                    orig.bind(target, x)();
+                                    return target;
+                                }
+                                CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, orig.bind(target, x));
+                                CFRunLoopWakeUp(runloop);
+                                return target;
+                            } : orig;
+                        }
+                    });
+                }
+            });
+        })();
+    )";
+
+    napi_value promiseProxyScript;
+    napi_create_string_utf8(env_, PromiseProxyScript, NAPI_AUTO_LENGTH, &promiseProxyScript);
+    napi_run_script(env_, promiseProxyScript, &result);
+    #endif  // TARGET_ENGINE_V8
+
   if (isWorker) {
     napi_property_descriptor prop = napi_util::desc("self", global);
     napi_define_properties(env_, global, 1, &prop);
   }
 
+  napi_property_descriptor prop = napi_util::desc(
+      "__drainMicrotaskQueue", drainMicrotasks, nullptr);
+  napi_define_properties(env_, global, 1, &prop);
+
   modules_.Init(env_, global);
 
   const char* metadata_path = std::getenv("NS_METADATA_PATH");
diff --git a/metadata-generator/src/IR/TypeSpec.cpp b/metadata-generator/src/IR/TypeSpec.cpp
@@ -22,12 +22,12 @@ TypeSpec::TypeSpec(CXType type, std::vector<std::string>* classTypeParameters) {
   std::string name = clang_getCString(nameStr);
   clang_disposeString(nameStr);
 
-  // if (std::find(KNOWN_BRIDGED_TYPES.begin(), KNOWN_BRIDGED_TYPES.end(),
-  //               name) != KNOWN_BRIDGED_TYPES.end()) {
-  //   kind = kTypeAnyObject;
-  //   // typeParameterName = name;
-  //   return;
-  // }
+  if (std::find(KNOWN_BRIDGED_TYPES.begin(), KNOWN_BRIDGED_TYPES.end(),
+                name) != KNOWN_BRIDGED_TYPES.end()) {
+    kind = kTypeAnyObject;
+    // typeParameterName = name;
+    return;
+  }
 
   CXString canonicalNameStr = clang_getTypeSpelling(canonicalType);
   std::string canonicalName = stripCInfo(clang_getCString(canonicalNameStr));
