feat: ES modules (ESM) support with conditional esm or commonjs consumption + better error handling

NativeScript/NativeScript-Prefix.pch

@@ -1,7 +1,7 @@
 #ifndef NativeScript_Prefix_pch
 #define NativeScript_Prefix_pch
 
-#define NATIVESCRIPT_VERSION "8.9.3"
+#define NATIVESCRIPT_VERSION "9.0.0"
 
 #ifdef DEBUG
 #define SIZEOF_OFF_T 8

NativeScript/NativeScript.mm

@@ -1,15 +1,20 @@
-#include <Foundation/Foundation.h>
 #include "NativeScript.h"
+#include <Foundation/Foundation.h>
 #include "inspector/JsV8InspectorClient.h"
 #include "runtime/Console.h"
-#include "runtime/RuntimeConfig.h"
 #include "runtime/Helpers.h"
 #include "runtime/Runtime.h"
+#include "runtime/RuntimeConfig.h"
 #include "runtime/Tasks.h"
 
 using namespace v8;
 using namespace tns;
 
+namespace tns {
+// External flag from Runtime.mm to track JavaScript errors
+extern bool jsErrorOccurred;
+}
+
 @implementation Config
 
 @synthesize BaseDir;
@@ -23,99 +28,110 @@ @implementation NativeScript
 
 extern char defaultStartOfMetadataSection __asm("section$start$__DATA$__TNSMetadata");
 
-- (void)runScriptString: (NSString*) script runLoop: (BOOL) runLoop {
+- (void)runScriptString:(NSString*)script runLoop:(BOOL)runLoop {
+  std::string cppString = std::string([script UTF8String]);
+  runtime_->RunScript(cppString);
 
-    std::string cppString = std::string([script UTF8String]);
-    runtime_->RunScript(cppString);
-
-    if (runLoop) {
-        CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true);
-    }
-
-
-    tns::Tasks::Drain();
+  if (runLoop) {
+    CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true);
+  }
 
+  tns::Tasks::Drain();
 }
 
 std::unique_ptr<Runtime> runtime_;
 
 - (void)runMainApplication {
-    runtime_->RunMainScript();
+  runtime_->RunMainScript();
 
-    CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true);
-    tns::Tasks::Drain();
+  // In debug mode, if JavaScript errors occurred, keep the app alive indefinitely
+  // This prevents iOS from terminating the app and allows hot-reload to work
+  if (RuntimeConfig.IsDebug && jsErrorOccurred) {
+    // Log(@"Debug mode - JavaScript errors detected, entering infinite run loop to prevent app termination");
+
+    while (true) {
+      CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, true);
+      tns::Tasks::Drain();
+    }
+    // Note: This line is never reached in debug mode with errors
+  }
+
+  // Normal execution path (no errors or release mode)
+  CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true);
+  tns::Tasks::Drain();
 }
 
 - (bool)liveSync {
-    if (runtime_ == nullptr) {
-        return false;
-    }
+  if (runtime_ == nullptr) {
+    return false;
+  }
 
-    Isolate* isolate = runtime_->GetIsolate();
-    return tns::LiveSync(isolate);
+  Isolate* isolate = runtime_->GetIsolate();
+  return tns::LiveSync(isolate);
 }
 
 - (void)shutdownRuntime {
-    if (RuntimeConfig.IsDebug) {
-        Console::DetachInspectorClient();
-    }
-    tns::Tasks::ClearTasks();
-    if (runtime_ != nullptr) {
-        runtime_ = nullptr;
-    }
+  if (RuntimeConfig.IsDebug) {
+    Console::DetachInspectorClient();
+  }
+  tns::Tasks::ClearTasks();
+  if (runtime_ != nullptr) {
+    runtime_ = nullptr;
+  }
 }
 
 - (instancetype)initializeWithConfig:(Config*)config {
-    if (self = [super init]) {
-        RuntimeConfig.BaseDir = [config.BaseDir UTF8String];
-        if (config.ApplicationPath != nil) {
-            RuntimeConfig.ApplicationPath = [[config.BaseDir stringByAppendingPathComponent:config.ApplicationPath] UTF8String];
-        } else {
-            RuntimeConfig.ApplicationPath = [[config.BaseDir stringByAppendingPathComponent:@"app"] UTF8String];
-        }
-        if (config.MetadataPtr != nil) {
-            RuntimeConfig.MetadataPtr = [config MetadataPtr];
-        } else {
-            RuntimeConfig.MetadataPtr = &defaultStartOfMetadataSection;
-        }
-        RuntimeConfig.IsDebug = [config IsDebug];
-        RuntimeConfig.LogToSystemConsole = [config LogToSystemConsole];
-
-        Runtime::Initialize();
-        runtime_ = nullptr;
-        runtime_ = std::make_unique<Runtime>();
-
-        std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
-        Isolate* isolate = runtime_->CreateIsolate();
-        v8::Locker l(isolate);
-        runtime_->Init(isolate);
-        std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
-        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count();
-        printf("Runtime initialization took %llims (version %s, V8 version %s)\n", duration,  NATIVESCRIPT_VERSION, V8::GetVersion());
-
-        if (config.IsDebug) {
-            Isolate::Scope isolate_scope(isolate);
-            HandleScope handle_scope(isolate);
-            v8_inspector::JsV8InspectorClient* inspectorClient = new v8_inspector::JsV8InspectorClient(runtime_.get());
-            inspectorClient->init();
-            inspectorClient->registerModules();
-            inspectorClient->connect([config ArgumentsCount], [config Arguments]);
-            Console::AttachInspectorClient(inspectorClient);
-        }
+  if (self = [super init]) {
+    RuntimeConfig.BaseDir = [config.BaseDir UTF8String];
+    if (config.ApplicationPath != nil) {
+      RuntimeConfig.ApplicationPath =
+          [[config.BaseDir stringByAppendingPathComponent:config.ApplicationPath] UTF8String];
+    } else {
+      RuntimeConfig.ApplicationPath =
+          [[config.BaseDir stringByAppendingPathComponent:@"app"] UTF8String];
+    }
+    if (config.MetadataPtr != nil) {
+      RuntimeConfig.MetadataPtr = [config MetadataPtr];
+    } else {
+      RuntimeConfig.MetadataPtr = &defaultStartOfMetadataSection;
+    }
+    RuntimeConfig.IsDebug = [config IsDebug];
+    RuntimeConfig.LogToSystemConsole = [config LogToSystemConsole];
+
+    Runtime::Initialize();
+    runtime_ = nullptr;
+    runtime_ = std::make_unique<Runtime>();
+
+    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+    Isolate* isolate = runtime_->CreateIsolate();
+    v8::Locker l(isolate);
+    runtime_->Init(isolate);
+    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count();
+    printf("Runtime initialization took %llims (version %s, V8 version %s)\n", duration,
+           NATIVESCRIPT_VERSION, V8::GetVersion());
+
+    if (config.IsDebug) {
+      Isolate::Scope isolate_scope(isolate);
+      HandleScope handle_scope(isolate);
+      v8_inspector::JsV8InspectorClient* inspectorClient =
+          new v8_inspector::JsV8InspectorClient(runtime_.get());
+      inspectorClient->init();
+      inspectorClient->registerModules();
+      inspectorClient->connect([config ArgumentsCount], [config Arguments]);
+      Console::AttachInspectorClient(inspectorClient);
     }
-    return self;
-    
+  }
+  return self;
 }
 
 - (instancetype)initWithConfig:(Config*)config {
-    return [self initializeWithConfig:config];
+  return [self initializeWithConfig:config];
 }
 
 - (void)restartWithConfig:(Config*)config {
-    [self shutdownRuntime];
-    [self initializeWithConfig:config];
+  [self shutdownRuntime];
+  [self initializeWithConfig:config];
 }
 
-
-
 @end

NativeScript/inspector/JsV8InspectorClient.mm

@@ -12,6 +12,7 @@
 #include "Helpers.h"
 #include "InspectorServer.h"
 #include "JsV8InspectorClient.h"
+#include "RuntimeConfig.h"
 #include "include/libplatform/libplatform.h"
 #include "utils.h"
 
@@ -392,7 +393,26 @@
   {
     v8::Locker locker(isolate);
     TryCatch tc(isolate);
-    runtime_->RunModule("inspector_modules");
+
+    // Check for ES module (.mjs) first, then fallback to CommonJS (.js)
+    NSString* appPath = [NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()];
+    NSString* mjsPath =
+        [[appPath stringByAppendingPathComponent:@"tns_modules/inspector_modules.mjs"]
+            stringByStandardizingPath];
+    NSString* jsPath = [[appPath stringByAppendingPathComponent:@"tns_modules/inspector_modules.js"]
+        stringByStandardizingPath];
+
+    std::string modulePath;
+    if ([[NSFileManager defaultManager] fileExistsAtPath:mjsPath]) {
+      modulePath = [mjsPath UTF8String];
+    } else if ([[NSFileManager defaultManager] fileExistsAtPath:jsPath]) {
+      modulePath = [jsPath UTF8String];
+    } else {
+      // No inspector modules found, skip loading
+      return;
+    }
+
+    runtime_->RunModule(modulePath);
     // FIXME: This triggers some DCHECK failures, due to the entered v8::Context in
     // Runtime::init().
   }