From 55c5c5198f04ff2b5cbe1be6f5add92acb3ed23f Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Fri, 6 Sep 2024 08:56:18 -0300
Subject: [PATCH 01/11] fix: revert visionOS changes to iOS project template

---
 .../__PROJECT_NAME__.xcodeproj/project.pbxproj              | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/project-template-ios/__PROJECT_NAME__.xcodeproj/project.pbxproj b/project-template-ios/__PROJECT_NAME__.xcodeproj/project.pbxproj
index 8e2eaa92..142e4274 100644
--- a/project-template-ios/__PROJECT_NAME__.xcodeproj/project.pbxproj
+++ b/project-template-ios/__PROJECT_NAME__.xcodeproj/project.pbxproj
@@ -314,7 +314,7 @@
 				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = NO;
+				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
@@ -356,6 +356,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
+				STRIP_SWIFT_SYMBOLS = NO;
 				SUPPORTS_UIKITFORMAC = YES;
 				SWIFT_OBJC_BRIDGING_HEADER = "$SRCROOT/internal/Swift-ObjC-Bridging-Header.h";
 				SWIFT_VERSION = 4.2;
@@ -370,7 +371,7 @@
 				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = NO;
+				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
@@ -408,6 +409,7 @@
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				SDKROOT = iphoneos;
+				STRIP_SWIFT_SYMBOLS = NO;
 				SUPPORTS_UIKITFORMAC = YES;
 				SWIFT_OBJC_BRIDGING_HEADER = "$SRCROOT/internal/Swift-ObjC-Bridging-Header.h";
 				SWIFT_VERSION = 4.2;

From 9d9f4aef03907908961ca6784220fa8aba9e5c03 Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Fri, 6 Sep 2024 09:40:21 -0300
Subject: [PATCH 02/11] chore: clang format ModuleInternal files

---
 NativeScript/runtime/ModuleInternal.h  | 118 ++--
 NativeScript/runtime/ModuleInternal.mm | 784 +++++++++++++------------
 2 files changed, 477 insertions(+), 425 deletions(-)

diff --git a/NativeScript/runtime/ModuleInternal.h b/NativeScript/runtime/ModuleInternal.h
index b81ada9a..25d223e9 100644
--- a/NativeScript/runtime/ModuleInternal.h
+++ b/NativeScript/runtime/ModuleInternal.h
@@ -7,57 +7,75 @@
 namespace tns {
 
 class ModuleInternal {
-public:
-    ModuleInternal(v8::Local<v8::Context> context);
-    bool RunModule(v8::Isolate* isolate, std::string path);
-    void RunScript(v8::Isolate* isolate, std::string script);
-
-private:
-    static void RequireCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    v8::Local<v8::Function> GetRequireFunction(v8::Isolate* isolate, const std::string& dirName);
-    v8::Local<v8::Object> LoadImpl(v8::Isolate* isolate, const std::string& moduleName, const std::string& baseDir, bool& isData);
-    v8::Local<v8::Script> LoadScript(v8::Isolate* isolate, const std::string& path);
-    v8::Local<v8::String> WrapModuleContent(v8::Isolate* isolate, const std::string& path);
-    v8::Local<v8::Object> LoadModule(v8::Isolate* isolate, const std::string& modulePath, const std::string& cacheKey);
-    v8::Local<v8::Object> LoadData(v8::Isolate* isolate, const std::string& modulePath);
-    std::string ResolvePath(v8::Isolate* isolate, const std::string& baseDir, const std::string& moduleName);
-    std::string ResolvePathFromPackageJson(const std::string& packageJson, bool& error);
-    v8::ScriptCompiler::CachedData* LoadScriptCache(const std::string& path);
-    void SaveScriptCache(const v8::Local<v8::Script> script, const std::string& path);
-    std::string GetCacheFileName(const std::string& path);
-    v8::MaybeLocal<v8::Value> RunScriptString(v8::Isolate* isolate, v8::Local<v8::Context> context, const std::string script);
-
-
-    std::unique_ptr<v8::Persistent<v8::Function>> requireFunction_;
-    std::unique_ptr<v8::Persistent<v8::Function>> requireFactoryFunction_;
-    robin_hood::unordered_map<std::string, std::shared_ptr<v8::Persistent<v8::Object>>> loadedModules_;
-
-    struct TempModule {
-    public:
-        TempModule(ModuleInternal* module, std::string modulePath, std::string cacheKey, std::shared_ptr<v8::Persistent<v8::Object>> poModuleObj)
-            : module_(module), dispose_(true), modulePath_(modulePath), cacheKey_(cacheKey) {
-            module->loadedModules_.emplace(modulePath, poModuleObj);
-            module->loadedModules_.emplace(cacheKey, poModuleObj);
-        }
-
-        ~TempModule() {
-            if (this->dispose_) {
-                this->module_->loadedModules_.erase(modulePath_);
-                this->module_->loadedModules_.erase(cacheKey_);
-            }
-        }
-
-        void SaveToCache() {
-            this->dispose_ = false;
-        }
-    private:
-        ModuleInternal* module_;
-        bool dispose_;
-        std::string modulePath_;
-        std::string cacheKey_;
-    };
+ public:
+  ModuleInternal(v8::Local<v8::Context> context);
+  bool RunModule(v8::Isolate* isolate, std::string path);
+  void RunScript(v8::Isolate* isolate, std::string script);
+
+ private:
+  static void RequireCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+  v8::Local<v8::Function> GetRequireFunction(v8::Isolate* isolate,
+                                             const std::string& dirName);
+  v8::Local<v8::Object> LoadImpl(v8::Isolate* isolate,
+                                 const std::string& moduleName,
+                                 const std::string& baseDir, bool& isData);
+  v8::Local<v8::Script> LoadScript(v8::Isolate* isolate,
+                                   const std::string& path);
+  v8::Local<v8::String> WrapModuleContent(v8::Isolate* isolate,
+                                          const std::string& path);
+  v8::Local<v8::Object> LoadModule(v8::Isolate* isolate,
+                                   const std::string& modulePath,
+                                   const std::string& cacheKey);
+  v8::Local<v8::Object> LoadData(v8::Isolate* isolate,
+                                 const std::string& modulePath);
+  std::string ResolvePath(v8::Isolate* isolate, const std::string& baseDir,
+                          const std::string& moduleName);
+  std::string ResolvePathFromPackageJson(const std::string& packageJson,
+                                         bool& error);
+  v8::ScriptCompiler::CachedData* LoadScriptCache(const std::string& path);
+  void SaveScriptCache(const v8::Local<v8::Script> script,
+                       const std::string& path);
+  std::string GetCacheFileName(const std::string& path);
+  v8::MaybeLocal<v8::Value> RunScriptString(v8::Isolate* isolate,
+                                            v8::Local<v8::Context> context,
+                                            const std::string script);
+
+  std::unique_ptr<v8::Persistent<v8::Function>> requireFunction_;
+  std::unique_ptr<v8::Persistent<v8::Function>> requireFactoryFunction_;
+  robin_hood::unordered_map<std::string,
+                            std::shared_ptr<v8::Persistent<v8::Object>>>
+      loadedModules_;
+
+  struct TempModule {
+   public:
+    TempModule(ModuleInternal* module, std::string modulePath,
+               std::string cacheKey,
+               std::shared_ptr<v8::Persistent<v8::Object>> poModuleObj)
+        : module_(module),
+          dispose_(true),
+          modulePath_(modulePath),
+          cacheKey_(cacheKey) {
+      module->loadedModules_.emplace(modulePath, poModuleObj);
+      module->loadedModules_.emplace(cacheKey, poModuleObj);
+    }
+
+    ~TempModule() {
+      if (this->dispose_) {
+        this->module_->loadedModules_.erase(modulePath_);
+        this->module_->loadedModules_.erase(cacheKey_);
+      }
+    }
+
+    void SaveToCache() { this->dispose_ = false; }
+
+   private:
+    ModuleInternal* module_;
+    bool dispose_;
+    std::string modulePath_;
+    std::string cacheKey_;
+  };
 };
 
-}
+}  // namespace tns
 
 #endif /* ModuleInternal_h */
diff --git a/NativeScript/runtime/ModuleInternal.mm b/NativeScript/runtime/ModuleInternal.mm
index 59292202..cd7aff47 100644
--- a/NativeScript/runtime/ModuleInternal.mm
+++ b/NativeScript/runtime/ModuleInternal.mm
@@ -1,468 +1,502 @@
+#include "ModuleInternal.h"
 #include <Foundation/Foundation.h>
-#include <string>
 #include <sys/stat.h>
-#include "ModuleInternal.h"
-#include "NativeScriptException.h"
-#include "RuntimeConfig.h"
+#include <string>
 #include "Caches.h"
 #include "Helpers.h"
+#include "NativeScriptException.h"
+#include "RuntimeConfig.h"
 
 using namespace v8;
 
 namespace tns {
 
 ModuleInternal::ModuleInternal(Local<Context> context) {
-    std::string requireFactoryScript =
-        "(function() { "
-        "    function require_factory(requireInternal, dirName) { "
-        "        return function require(modulePath) { "
-        "            if(global.__pauseOnNextRequire) {  debugger; global.__pauseOnNextRequire = false; }"
-        "            return requireInternal(modulePath, dirName); "
-        "        } "
-        "    } "
-        "    return require_factory; "
-        "})()";
-
-    Isolate* isolate = context->GetIsolate();
-    Local<Object> global = context->Global();
-    Local<Script> script;
-    TryCatch tc(isolate);
-    if (!Script::Compile(context, tns::ToV8String(isolate, requireFactoryScript.c_str())).ToLocal(&script) && tc.HasCaught()) {
-        tns::LogError(isolate, tc);
-        tns::Assert(false, isolate);
-    }
-    tns::Assert(!script.IsEmpty(), isolate);
-
-    Local<Value> result;
-    if (!script->Run(context).ToLocal(&result) && tc.HasCaught()) {
-        tns::LogError(isolate, tc);
-        tns::Assert(false, isolate);
-    }
-    tns::Assert(!result.IsEmpty() && result->IsFunction(), isolate);
-
-    this->requireFactoryFunction_ = std::make_unique<Persistent<v8::Function>>(isolate, result.As<v8::Function>());
-
-    Local<FunctionTemplate> requireFuncTemplate = FunctionTemplate::New(isolate, RequireCallback, External::New(isolate, this));
-    this->requireFunction_ = std::make_unique<Persistent<v8::Function>>(isolate, requireFuncTemplate->GetFunction(context).ToLocalChecked());
-
-    Local<v8::Function> globalRequire = GetRequireFunction(isolate, RuntimeConfig.ApplicationPath);
-    bool success = global->Set(context, tns::ToV8String(isolate, "require"), globalRequire).FromMaybe(false);
-    tns::Assert(success, isolate);
+  std::string requireFactoryScript = "(function() { "
+                                     "    function require_factory(requireInternal, dirName) { "
+                                     "        return function require(modulePath) { "
+                                     "            if(global.__pauseOnNextRequire) {  debugger; "
+                                     "global.__pauseOnNextRequire = false; }"
+                                     "            return requireInternal(modulePath, dirName); "
+                                     "        } "
+                                     "    } "
+                                     "    return require_factory; "
+                                     "})()";
+
+  Isolate* isolate = context->GetIsolate();
+  Local<Object> global = context->Global();
+  Local<Script> script;
+  TryCatch tc(isolate);
+  if (!Script::Compile(context, tns::ToV8String(isolate, requireFactoryScript.c_str()))
+           .ToLocal(&script) &&
+      tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+    tns::Assert(false, isolate);
+  }
+  tns::Assert(!script.IsEmpty(), isolate);
+
+  Local<Value> result;
+  if (!script->Run(context).ToLocal(&result) && tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+    tns::Assert(false, isolate);
+  }
+  tns::Assert(!result.IsEmpty() && result->IsFunction(), isolate);
+
+  this->requireFactoryFunction_ =
+      std::make_unique<Persistent<v8::Function>>(isolate, result.As<v8::Function>());
+
+  Local<FunctionTemplate> requireFuncTemplate =
+      FunctionTemplate::New(isolate, RequireCallback, External::New(isolate, this));
+  this->requireFunction_ = std::make_unique<Persistent<v8::Function>>(
+      isolate, requireFuncTemplate->GetFunction(context).ToLocalChecked());
+
+  Local<v8::Function> globalRequire = GetRequireFunction(isolate, RuntimeConfig.ApplicationPath);
+  bool success =
+      global->Set(context, tns::ToV8String(isolate, "require"), globalRequire).FromMaybe(false);
+  tns::Assert(success, isolate);
 }
 
 bool ModuleInternal::RunModule(Isolate* isolate, std::string path) {
-    std::shared_ptr<Caches> cache = Caches::Get(isolate);
-    Local<Context> context = cache->GetContext();
-    Local<Object> globalObject = context->Global();
-    Local<Value> requireObj;
-    bool success = globalObject->Get(context, ToV8String(isolate, "require")).ToLocal(&requireObj);
-    tns::Assert(success && requireObj->IsFunction(), isolate);
-    Local<v8::Function> requireFunc = requireObj.As<v8::Function>();
-    Local<Value> args[] = { ToV8String(isolate, path) };
-    Local<Value> result;
-    success = requireFunc->Call(context, globalObject, 1, args).ToLocal(&result);
-    return success;
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  Local<Context> context = cache->GetContext();
+  Local<Object> globalObject = context->Global();
+  Local<Value> requireObj;
+  bool success = globalObject->Get(context, ToV8String(isolate, "require")).ToLocal(&requireObj);
+  tns::Assert(success && requireObj->IsFunction(), isolate);
+  Local<v8::Function> requireFunc = requireObj.As<v8::Function>();
+  Local<Value> args[] = {ToV8String(isolate, path)};
+  Local<Value> result;
+  success = requireFunc->Call(context, globalObject, 1, args).ToLocal(&result);
+  return success;
 }
 
-Local<v8::Function> ModuleInternal::GetRequireFunction(Isolate* isolate, const std::string& dirName) {
-    Local<v8::Function> requireFuncFactory = requireFactoryFunction_->Get(isolate);
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<v8::Function> requireInternalFunc = this->requireFunction_->Get(isolate);
-    Local<Value> args[2] {
-        requireInternalFunc, tns::ToV8String(isolate, dirName.c_str())
-    };
+Local<v8::Function> ModuleInternal::GetRequireFunction(Isolate* isolate,
+                                                       const std::string& dirName) {
+  Local<v8::Function> requireFuncFactory = requireFactoryFunction_->Get(isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<v8::Function> requireInternalFunc = this->requireFunction_->Get(isolate);
+  Local<Value> args[2]{requireInternalFunc, tns::ToV8String(isolate, dirName.c_str())};
 
-    Local<Value> result;
-    Local<Object> thiz = Object::New(isolate);
-    bool success = requireFuncFactory->Call(context, thiz, 2, args).ToLocal(&result);
-    tns::Assert(success && !result.IsEmpty() && result->IsFunction(), isolate);
+  Local<Value> result;
+  Local<Object> thiz = Object::New(isolate);
+  bool success = requireFuncFactory->Call(context, thiz, 2, args).ToLocal(&result);
+  tns::Assert(success && !result.IsEmpty() && result->IsFunction(), isolate);
 
-    return result.As<v8::Function>();
+  return result.As<v8::Function>();
 }
 
 void ModuleInternal::RequireCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-
-    try {
-        ModuleInternal* moduleInternal = static_cast<ModuleInternal*>(info.Data().As<External>()->Value());
-
-        std::string moduleName = tns::ToString(isolate, info[0].As<v8::String>());
-        std::string callingModuleDirName = tns::ToString(isolate, info[1].As<v8::String>());
-
-        NSString* fullPath;
-        if (moduleName.length() > 0 && moduleName[0] != '/') {
-            if (moduleName[0] == '.') {
-                fullPath = [[NSString stringWithUTF8String:callingModuleDirName.c_str()] stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
-            } else if (moduleName[0] == '~') {
-                moduleName = moduleName.substr(2);
-                fullPath = [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()] stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
-            } else {
-                NSString* tnsModulesPath = [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()] stringByAppendingPathComponent:@"tns_modules"];
-                fullPath = [tnsModulesPath stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
-
-                const char* path1 = [fullPath fileSystemRepresentation];
-                const char* path2 = [[fullPath stringByAppendingPathExtension:@"js"] fileSystemRepresentation];
-
-                if (!tns::Exists(path1) && !tns::Exists(path2)) {
-                    fullPath = [tnsModulesPath stringByAppendingPathComponent:@"tns-core-modules"];
-                    fullPath = [fullPath stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
-                }
-            }
-        } else {
-            fullPath = [NSString stringWithUTF8String:moduleName.c_str()];
+  Isolate* isolate = info.GetIsolate();
+
+  try {
+    ModuleInternal* moduleInternal =
+        static_cast<ModuleInternal*>(info.Data().As<External>()->Value());
+
+    std::string moduleName = tns::ToString(isolate, info[0].As<v8::String>());
+    std::string callingModuleDirName = tns::ToString(isolate, info[1].As<v8::String>());
+
+    NSString* fullPath;
+    if (moduleName.length() > 0 && moduleName[0] != '/') {
+      if (moduleName[0] == '.') {
+        fullPath = [[NSString stringWithUTF8String:callingModuleDirName.c_str()]
+            stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
+      } else if (moduleName[0] == '~') {
+        moduleName = moduleName.substr(2);
+        fullPath = [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()]
+            stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
+      } else {
+        NSString* tnsModulesPath =
+            [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()]
+                stringByAppendingPathComponent:@"tns_modules"];
+        fullPath = [tnsModulesPath
+            stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
+
+        const char* path1 = [fullPath fileSystemRepresentation];
+        const char* path2 =
+            [[fullPath stringByAppendingPathExtension:@"js"] fileSystemRepresentation];
+
+        if (!tns::Exists(path1) && !tns::Exists(path2)) {
+          fullPath = [tnsModulesPath stringByAppendingPathComponent:@"tns-core-modules"];
+          fullPath = [fullPath
+              stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
         }
-
-        NSString* fileNameOnly = [fullPath lastPathComponent];
-        NSString* pathOnly = [fullPath stringByDeletingLastPathComponent];
-
-        bool isData = false;
-        Local<Object> moduleObj = moduleInternal->LoadImpl(isolate, [fileNameOnly UTF8String], [pathOnly UTF8String], isData);
-        if (moduleObj.IsEmpty()) {
-            return;
-        }
-
-        if (isData) {
-            tns::Assert(!moduleObj.IsEmpty(), isolate);
-            info.GetReturnValue().Set(moduleObj);
-        } else {
-            Local<Context> context = isolate->GetCurrentContext();
-            Local<Value> exportsObj;
-            bool success = moduleObj->Get(context, tns::ToV8String(isolate, "exports")).ToLocal(&exportsObj);
-            tns::Assert(success, isolate);
-            info.GetReturnValue().Set(exportsObj);
-        }
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
-    }
-}
-
-Local<Object> ModuleInternal::LoadImpl(Isolate* isolate, const std::string& moduleName, const std::string& baseDir, bool& isData) {
-    size_t lastIndex = moduleName.find_last_of(".");
-    std::string moduleNameWithoutExtension = (lastIndex == std::string::npos) ? moduleName : moduleName.substr(0, lastIndex);
-    std::string cacheKey = baseDir + "*" + moduleNameWithoutExtension;
-    auto it = this->loadedModules_.find(cacheKey);
-
-    if (it != this->loadedModules_.end()) {
-        return it->second->Get(isolate);
-    }
-
-    Local<Object> moduleObj;
-    Local<Value> exportsObj;
-    std::string path = this->ResolvePath(isolate, baseDir, moduleName);
-    if (path.empty()) {
-        return Local<Object>();
+      }
+    } else {
+      fullPath = [NSString stringWithUTF8String:moduleName.c_str()];
     }
 
-    NSString* pathStr = [NSString stringWithUTF8String:path.c_str()];
-    NSString* extension = [pathStr pathExtension];
-    if ([extension isEqualToString:@"json"]) {
-        isData = true;
-    }
+    NSString* fileNameOnly = [fullPath lastPathComponent];
+    NSString* pathOnly = [fullPath stringByDeletingLastPathComponent];
 
-    auto it2 = this->loadedModules_.find(path);
-    if (it2 != this->loadedModules_.end()) {
-        return it2->second->Get(isolate);
+    bool isData = false;
+    Local<Object> moduleObj =
+        moduleInternal->LoadImpl(isolate, [fileNameOnly UTF8String], [pathOnly UTF8String], isData);
+    if (moduleObj.IsEmpty()) {
+      return;
     }
 
-    if ([extension isEqualToString:@"js"]) {
-        moduleObj = this->LoadModule(isolate, path, cacheKey);
-    } else if ([extension isEqualToString:@"json"]) {
-        moduleObj = this->LoadData(isolate, path);
+    if (isData) {
+      tns::Assert(!moduleObj.IsEmpty(), isolate);
+      info.GetReturnValue().Set(moduleObj);
     } else {
-        // TODO: throw an error for unsupported file extension
-        tns::Assert(false, isolate);
-    }
+      Local<Context> context = isolate->GetCurrentContext();
+      Local<Value> exportsObj;
+      bool success =
+          moduleObj->Get(context, tns::ToV8String(isolate, "exports")).ToLocal(&exportsObj);
+      tns::Assert(success, isolate);
+      info.GetReturnValue().Set(exportsObj);
+    }
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
+}
 
-    return moduleObj;
+Local<Object> ModuleInternal::LoadImpl(Isolate* isolate, const std::string& moduleName,
+                                       const std::string& baseDir, bool& isData) {
+  size_t lastIndex = moduleName.find_last_of(".");
+  std::string moduleNameWithoutExtension =
+      (lastIndex == std::string::npos) ? moduleName : moduleName.substr(0, lastIndex);
+  std::string cacheKey = baseDir + "*" + moduleNameWithoutExtension;
+  auto it = this->loadedModules_.find(cacheKey);
+
+  if (it != this->loadedModules_.end()) {
+    return it->second->Get(isolate);
+  }
+
+  Local<Object> moduleObj;
+  Local<Value> exportsObj;
+  std::string path = this->ResolvePath(isolate, baseDir, moduleName);
+  if (path.empty()) {
+    return Local<Object>();
+  }
+
+  NSString* pathStr = [NSString stringWithUTF8String:path.c_str()];
+  NSString* extension = [pathStr pathExtension];
+  if ([extension isEqualToString:@"json"]) {
+    isData = true;
+  }
+
+  auto it2 = this->loadedModules_.find(path);
+  if (it2 != this->loadedModules_.end()) {
+    return it2->second->Get(isolate);
+  }
+
+  if ([extension isEqualToString:@"js"]) {
+    moduleObj = this->LoadModule(isolate, path, cacheKey);
+  } else if ([extension isEqualToString:@"json"]) {
+    moduleObj = this->LoadData(isolate, path);
+  } else {
+    // TODO: throw an error for unsupported file extension
+    tns::Assert(false, isolate);
+  }
+
+  return moduleObj;
 }
 
-Local<Object> ModuleInternal::LoadModule(Isolate* isolate, const std::string& modulePath, const std::string& cacheKey) {
-    Local<Object> moduleObj = Object::New(isolate);
-    Local<Object> exportsObj = Object::New(isolate);
-    Local<Context> context = isolate->GetCurrentContext();
-    bool success = moduleObj->Set(context, tns::ToV8String(isolate, "exports"), exportsObj).FromMaybe(false);
-    tns::Assert(success, isolate);
+Local<Object> ModuleInternal::LoadModule(Isolate* isolate, const std::string& modulePath,
+                                         const std::string& cacheKey) {
+  Local<Object> moduleObj = Object::New(isolate);
+  Local<Object> exportsObj = Object::New(isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+  bool success =
+      moduleObj->Set(context, tns::ToV8String(isolate, "exports"), exportsObj).FromMaybe(false);
+  tns::Assert(success, isolate);
 
-    const PropertyAttribute readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+  const PropertyAttribute readOnlyFlags =
+      static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
 
-    Local<v8::String> fileName = tns::ToV8String(isolate, modulePath);
-    success = moduleObj->DefineOwnProperty(context, tns::ToV8String(isolate, "id"), fileName, readOnlyFlags).FromMaybe(false);
-    tns::Assert(success, isolate);
+  Local<v8::String> fileName = tns::ToV8String(isolate, modulePath);
+  success =
+      moduleObj->DefineOwnProperty(context, tns::ToV8String(isolate, "id"), fileName, readOnlyFlags)
+          .FromMaybe(false);
+  tns::Assert(success, isolate);
 
-    std::shared_ptr<Persistent<Object>> poModuleObj = std::make_shared<Persistent<Object>>(isolate, moduleObj);
-    TempModule tempModule(this, modulePath, cacheKey, poModuleObj);
+  std::shared_ptr<Persistent<Object>> poModuleObj =
+      std::make_shared<Persistent<Object>>(isolate, moduleObj);
+  TempModule tempModule(this, modulePath, cacheKey, poModuleObj);
 
-    Local<Script> script = LoadScript(isolate, modulePath);
+  Local<Script> script = LoadScript(isolate, modulePath);
 
-    Local<v8::Function> moduleFunc;
-    {
-        TryCatch tc(isolate);
-        moduleFunc = script->Run(context).ToLocalChecked().As<v8::Function>();
-        if (tc.HasCaught()) {
-            throw NativeScriptException(isolate, tc, "Error running script " + modulePath);
-        }
+  Local<v8::Function> moduleFunc;
+  {
+    TryCatch tc(isolate);
+    moduleFunc = script->Run(context).ToLocalChecked().As<v8::Function>();
+    if (tc.HasCaught()) {
+      throw NativeScriptException(isolate, tc, "Error running script " + modulePath);
     }
+  }
 
-    std::string parentDir = [[[NSString stringWithUTF8String:modulePath.c_str()] stringByDeletingLastPathComponent] UTF8String];
-    Local<v8::Function> require = GetRequireFunction(isolate, parentDir);
-    Local<Value> requireArgs[5] {
-        moduleObj, exportsObj, require, tns::ToV8String(isolate, modulePath.c_str()), tns::ToV8String(isolate, parentDir.c_str())
-    };
-
-    success = moduleObj->Set(context, tns::ToV8String(isolate, "require"), require).FromMaybe(false);
-    tns::Assert(success, isolate);
-
-    {
-        TryCatch tc(isolate);
-        Local<Value> result;
-        Local<Object> thiz = Object::New(isolate);
-        success = moduleFunc->Call(context, thiz, sizeof(requireArgs) / sizeof(Local<Value>), requireArgs).ToLocal(&result);
-        if (!success || tc.HasCaught()) {
-            throw NativeScriptException(isolate, tc, "Error calling module function");
-        }
+  std::string parentDir = [[[NSString stringWithUTF8String:modulePath.c_str()]
+      stringByDeletingLastPathComponent] UTF8String];
+  Local<v8::Function> require = GetRequireFunction(isolate, parentDir);
+  Local<Value> requireArgs[5]{moduleObj, exportsObj, require,
+                              tns::ToV8String(isolate, modulePath.c_str()),
+                              tns::ToV8String(isolate, parentDir.c_str())};
+
+  success = moduleObj->Set(context, tns::ToV8String(isolate, "require"), require).FromMaybe(false);
+  tns::Assert(success, isolate);
+
+  {
+    TryCatch tc(isolate);
+    Local<Value> result;
+    Local<Object> thiz = Object::New(isolate);
+    success =
+        moduleFunc->Call(context, thiz, sizeof(requireArgs) / sizeof(Local<Value>), requireArgs)
+            .ToLocal(&result);
+    if (!success || tc.HasCaught()) {
+      throw NativeScriptException(isolate, tc, "Error calling module function");
     }
+  }
 
-    tempModule.SaveToCache();
-    return moduleObj;
+  tempModule.SaveToCache();
+  return moduleObj;
 }
 
 Local<Object> ModuleInternal::LoadData(Isolate* isolate, const std::string& modulePath) {
-    Local<Object> json;
+  Local<Object> json;
 
-    std::string jsonData = tns::ReadText(modulePath);
+  std::string jsonData = tns::ReadText(modulePath);
 
-    Local<v8::String> jsonStr = tns::ToV8String(isolate, jsonData);
+  Local<v8::String> jsonStr = tns::ToV8String(isolate, jsonData);
 
-    Local<Context> context = isolate->GetCurrentContext();
-    TryCatch tc(isolate);
-    MaybeLocal<Value> maybeValue = JSON::Parse(context, jsonStr);
-    if (maybeValue.IsEmpty() || tc.HasCaught()) {
-        std::string errMsg = "Cannot parse JSON file " + modulePath;
-        throw NativeScriptException(isolate, tc, errMsg);
-    }
+  Local<Context> context = isolate->GetCurrentContext();
+  TryCatch tc(isolate);
+  MaybeLocal<Value> maybeValue = JSON::Parse(context, jsonStr);
+  if (maybeValue.IsEmpty() || tc.HasCaught()) {
+    std::string errMsg = "Cannot parse JSON file " + modulePath;
+    throw NativeScriptException(isolate, tc, errMsg);
+  }
 
-    Local<Value> value = maybeValue.ToLocalChecked();
-    if (!value->IsObject()) {
-        std::string errMsg = "JSON is not valid, file=" + modulePath;
-        throw NativeScriptException(errMsg);
-    }
+  Local<Value> value = maybeValue.ToLocalChecked();
+  if (!value->IsObject()) {
+    std::string errMsg = "JSON is not valid, file=" + modulePath;
+    throw NativeScriptException(errMsg);
+  }
 
-    json = value.As<Object>();
+  json = value.As<Object>();
 
-    this->loadedModules_.emplace(modulePath, std::make_shared<Persistent<Object>>(isolate, json));
+  this->loadedModules_.emplace(modulePath, std::make_shared<Persistent<Object>>(isolate, json));
 
-    return json;
+  return json;
 }
 
 Local<Script> ModuleInternal::LoadScript(Isolate* isolate, const std::string& path) {
-    Local<Context> context = isolate->GetCurrentContext();
-    std::string baseOrigin = tns::ReplaceAll(path, RuntimeConfig.BaseDir, "");
-    std::string fullRequiredModulePathWithSchema = "file://" + baseOrigin;
-    ScriptOrigin origin(isolate, tns::ToV8String(isolate, fullRequiredModulePathWithSchema));
-    Local<v8::String> scriptText = WrapModuleContent(isolate, path);
-    ScriptCompiler::CachedData* cacheData = LoadScriptCache(path);
-    ScriptCompiler::Source source(scriptText, origin, cacheData);
-
-    ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
-
-    if (cacheData != nullptr) {
-        options = ScriptCompiler::kConsumeCodeCache;
-    }
-
-    Local<Script> script;
-    TryCatch tc(isolate);
-    bool success = ScriptCompiler::Compile(context, &source, options).ToLocal(&script);
-    if (!success || tc.HasCaught()) {
-        throw NativeScriptException(isolate, tc, "Cannot compile " + path);
-    }
-
-    if (cacheData == nullptr) {
-        SaveScriptCache(script, path);
-    }
-
-    return script;
+  Local<Context> context = isolate->GetCurrentContext();
+  std::string baseOrigin = tns::ReplaceAll(path, RuntimeConfig.BaseDir, "");
+  std::string fullRequiredModulePathWithSchema = "file://" + baseOrigin;
+  ScriptOrigin origin(isolate, tns::ToV8String(isolate, fullRequiredModulePathWithSchema));
+  Local<v8::String> scriptText = WrapModuleContent(isolate, path);
+  ScriptCompiler::CachedData* cacheData = LoadScriptCache(path);
+  ScriptCompiler::Source source(scriptText, origin, cacheData);
+
+  ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
+
+  if (cacheData != nullptr) {
+    options = ScriptCompiler::kConsumeCodeCache;
+  }
+
+  Local<Script> script;
+  TryCatch tc(isolate);
+  bool success = ScriptCompiler::Compile(context, &source, options).ToLocal(&script);
+  if (!success || tc.HasCaught()) {
+    throw NativeScriptException(isolate, tc, "Cannot compile " + path);
+  }
+
+  if (cacheData == nullptr) {
+    SaveScriptCache(script, path);
+  }
+
+  return script;
 }
 
-MaybeLocal<Value> ModuleInternal::RunScriptString(Isolate* isolate, Local<Context> context, const std::string scriptString) {
-    ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
-    ScriptCompiler::Source source(tns::ToV8String(isolate, scriptString));
-    TryCatch tc(isolate);
-    Local<Script> script = ScriptCompiler::Compile(context, &source, options).ToLocalChecked();
-    MaybeLocal<Value> result = script->Run(context);
-    return result;
+MaybeLocal<Value> ModuleInternal::RunScriptString(Isolate* isolate, Local<Context> context,
+                                                  const std::string scriptString) {
+  ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
+  ScriptCompiler::Source source(tns::ToV8String(isolate, scriptString));
+  TryCatch tc(isolate);
+  Local<Script> script = ScriptCompiler::Compile(context, &source, options).ToLocalChecked();
+  MaybeLocal<Value> result = script->Run(context);
+  return result;
 }
 
-
 void ModuleInternal::RunScript(Isolate* isolate, std::string script) {
-    std::shared_ptr<Caches> cache = Caches::Get(isolate);
-    Local<Context> context = cache->GetContext();
-    Local<Object> globalObject = context->Global();
-    Local<Value> requireObj;
-    bool success = globalObject->Get(context, ToV8String(isolate, "require")).ToLocal(&requireObj);
-    tns::Assert(success && requireObj->IsFunction(), isolate);
-    Local<Value> result;
-    this->RunScriptString(isolate, context, script);
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  Local<Context> context = cache->GetContext();
+  Local<Object> globalObject = context->Global();
+  Local<Value> requireObj;
+  bool success = globalObject->Get(context, ToV8String(isolate, "require")).ToLocal(&requireObj);
+  tns::Assert(success && requireObj->IsFunction(), isolate);
+  Local<Value> result;
+  this->RunScriptString(isolate, context, script);
 }
 
-
 Local<v8::String> ModuleInternal::WrapModuleContent(Isolate* isolate, const std::string& path) {
-    return tns::ReadModule(isolate, path);
+  return tns::ReadModule(isolate, path);
 }
 
-std::string ModuleInternal::ResolvePath(Isolate* isolate, const std::string& baseDir, const std::string& moduleName) {
-    NSString* baseDirStr = [NSString stringWithUTF8String:baseDir.c_str()];
-    NSString* moduleNameStr = [NSString stringWithUTF8String:moduleName.c_str()];
-    NSString* fullPath = [[baseDirStr stringByAppendingPathComponent:moduleNameStr] stringByStandardizingPath];
-
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    BOOL isDirectory;
-    BOOL exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
-
-    if (exists == YES && isDirectory == YES) {
-        NSString* jsFile = [fullPath stringByAppendingPathExtension:@"js"];
-        BOOL isDir;
-        if ([fileManager fileExistsAtPath:jsFile isDirectory:&isDir] && isDir == NO) {
-            return [jsFile UTF8String];
-        }
-    }
-
-    if (exists == NO) {
-        fullPath = [fullPath stringByAppendingPathExtension:@"js"];
-        exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
-    }
-
-    if (exists == NO) {
-        throw NativeScriptException("The specified module does not exist: " + moduleName);
-    }
-
-    if (isDirectory == NO) {
-        return [fullPath UTF8String];
-    }
+std::string ModuleInternal::ResolvePath(Isolate* isolate, const std::string& baseDir,
+                                        const std::string& moduleName) {
+  NSString* baseDirStr = [NSString stringWithUTF8String:baseDir.c_str()];
+  NSString* moduleNameStr = [NSString stringWithUTF8String:moduleName.c_str()];
+  NSString* fullPath =
+      [[baseDirStr stringByAppendingPathComponent:moduleNameStr] stringByStandardizingPath];
 
-    // Try to resolve module from main entry in package.json
-    NSString* packageJson = [fullPath stringByAppendingPathComponent:@"package.json"];
-    bool error = false;
-    std::string entry = this->ResolvePathFromPackageJson([packageJson UTF8String], error);
-    if (error) {
-        throw NativeScriptException("Unable to locate main entry in " + std::string([packageJson UTF8String]));
-    }
+  NSFileManager* fileManager = [NSFileManager defaultManager];
+  BOOL isDirectory;
+  BOOL exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
 
-    if (!entry.empty()) {
-        fullPath = [NSString stringWithUTF8String:entry.c_str()];
+  if (exists == YES && isDirectory == YES) {
+    NSString* jsFile = [fullPath stringByAppendingPathExtension:@"js"];
+    BOOL isDir;
+    if ([fileManager fileExistsAtPath:jsFile isDirectory:&isDir] && isDir == NO) {
+      return [jsFile UTF8String];
     }
+  }
 
+  if (exists == NO) {
+    fullPath = [fullPath stringByAppendingPathExtension:@"js"];
     exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
-    if (exists == YES && isDirectory == NO) {
-        return [fullPath UTF8String];
-    }
-
-    if (exists == NO) {
-        fullPath = [fullPath stringByAppendingPathExtension:@"js"];
-    } else {
-        fullPath = [fullPath stringByAppendingPathComponent:@"index.js"];
-    }
+  }
 
-    exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
-    if (exists == NO) {
-        throw NativeScriptException("The specified module does not exist: " + moduleName);
-    }
+  if (exists == NO) {
+    throw NativeScriptException("The specified module does not exist: " + moduleName);
+  }
 
+  if (isDirectory == NO) {
     return [fullPath UTF8String];
-}
-
-std::string ModuleInternal::ResolvePathFromPackageJson(const std::string& packageJson, bool& error) {
-    NSString* packageJsonStr = [NSString stringWithUTF8String:packageJson.c_str()];
-
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    BOOL isDirectory;
-    BOOL exists = [fileManager fileExistsAtPath:packageJsonStr isDirectory:&isDirectory];
-    if (exists == NO || isDirectory == YES) {
-        return std::string();
-    }
-
-    NSData *data = [NSData dataWithContentsOfFile:packageJsonStr];
-    if (data == nil) {
-        return std::string();
-    }
+  }
+
+  // Try to resolve module from main entry in package.json
+  NSString* packageJson = [fullPath stringByAppendingPathComponent:@"package.json"];
+  bool error = false;
+  std::string entry = this->ResolvePathFromPackageJson([packageJson UTF8String], error);
+  if (error) {
+    throw NativeScriptException("Unable to locate main entry in " +
+                                std::string([packageJson UTF8String]));
+  }
+
+  if (!entry.empty()) {
+    fullPath = [NSString stringWithUTF8String:entry.c_str()];
+  }
+
+  exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
+  if (exists == YES && isDirectory == NO) {
+    return [fullPath UTF8String];
+  }
 
-    NSDictionary* dic = [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:nil];
-    if (dic == nil) {
-        error = true;
-        return std::string();
-    }
+  if (exists == NO) {
+    fullPath = [fullPath stringByAppendingPathExtension:@"js"];
+  } else {
+    fullPath = [fullPath stringByAppendingPathComponent:@"index.js"];
+  }
 
-    NSString *main = [dic objectForKey:@"main"];
-    if (main == nil) {
-        return std::string();
-    }
+  exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
+  if (exists == NO) {
+    throw NativeScriptException("The specified module does not exist: " + moduleName);
+  }
 
-    NSString* path = [[[packageJsonStr stringByDeletingLastPathComponent] stringByAppendingPathComponent:main] stringByStandardizingPath];
-    exists = [fileManager fileExistsAtPath:path isDirectory:&isDirectory];
+  return [fullPath UTF8String];
+}
 
-    if (exists == YES && isDirectory == YES) {
-        packageJsonStr = [path stringByAppendingPathComponent:@"package.json"];
-        exists = [fileManager fileExistsAtPath:packageJsonStr isDirectory:&isDirectory];
-        if (exists == YES && isDirectory == NO) {
-            return this->ResolvePathFromPackageJson([packageJsonStr UTF8String], error);
-        }
+std::string ModuleInternal::ResolvePathFromPackageJson(const std::string& packageJson,
+                                                       bool& error) {
+  NSString* packageJsonStr = [NSString stringWithUTF8String:packageJson.c_str()];
+
+  NSFileManager* fileManager = [NSFileManager defaultManager];
+  BOOL isDirectory;
+  BOOL exists = [fileManager fileExistsAtPath:packageJsonStr isDirectory:&isDirectory];
+  if (exists == NO || isDirectory == YES) {
+    return std::string();
+  }
+
+  NSData* data = [NSData dataWithContentsOfFile:packageJsonStr];
+  if (data == nil) {
+    return std::string();
+  }
+
+  NSDictionary* dic = [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:nil];
+  if (dic == nil) {
+    error = true;
+    return std::string();
+  }
+
+  NSString* main = [dic objectForKey:@"main"];
+  if (main == nil) {
+    return std::string();
+  }
+
+  NSString* path = [[[packageJsonStr stringByDeletingLastPathComponent]
+      stringByAppendingPathComponent:main] stringByStandardizingPath];
+  exists = [fileManager fileExistsAtPath:path isDirectory:&isDirectory];
+
+  if (exists == YES && isDirectory == YES) {
+    packageJsonStr = [path stringByAppendingPathComponent:@"package.json"];
+    exists = [fileManager fileExistsAtPath:packageJsonStr isDirectory:&isDirectory];
+    if (exists == YES && isDirectory == NO) {
+      return this->ResolvePathFromPackageJson([packageJsonStr UTF8String], error);
     }
+  }
 
-    return [path UTF8String];
+  return [path UTF8String];
 }
 
 ScriptCompiler::CachedData* ModuleInternal::LoadScriptCache(const std::string& path) {
-    if (RuntimeConfig.IsDebug) {
+  if (RuntimeConfig.IsDebug) {
+    return nullptr;
+  }
+
+  long length = 0;
+  std::string cachePath = GetCacheFileName(path + ".cache");
+
+  struct stat result;
+  if (stat(cachePath.c_str(), &result) == 0) {
+    auto cacheLastModifiedTime = result.st_mtime;
+    if (stat(path.c_str(), &result) == 0) {
+      auto jsLastModifiedTime = result.st_mtime;
+      if (jsLastModifiedTime > 0 && cacheLastModifiedTime > 0 &&
+          jsLastModifiedTime > cacheLastModifiedTime) {
+        // The javascript file is more recent than the cache file => ignore the cache
         return nullptr;
+      }
     }
+  }
 
-    long length = 0;
-    std::string cachePath = GetCacheFileName(path + ".cache");
-
-    struct stat result;
-    if (stat(cachePath.c_str(), &result) == 0) {
-        auto cacheLastModifiedTime = result.st_mtime;
-        if (stat(path.c_str(), &result) == 0) {
-            auto jsLastModifiedTime = result.st_mtime;
-            if (jsLastModifiedTime > 0 && cacheLastModifiedTime > 0 && jsLastModifiedTime > cacheLastModifiedTime) {
-                // The javascript file is more recent than the cache file => ignore the cache
-                return nullptr;
-            }
-        }
-    }
-
-    bool isNew = false;
-    uint8_t* data = tns::ReadBinary(cachePath, length, isNew);
-    if (!data) {
-        return nullptr;
-    }
+  bool isNew = false;
+  uint8_t* data = tns::ReadBinary(cachePath, length, isNew);
+  if (!data) {
+    return nullptr;
+  }
 
-    return new ScriptCompiler::CachedData(data, (int)length, isNew ? ScriptCompiler::CachedData::BufferOwned : ScriptCompiler::CachedData::BufferNotOwned);
+  return new ScriptCompiler::CachedData(
+      data, (int)length,
+      isNew ? ScriptCompiler::CachedData::BufferOwned : ScriptCompiler::CachedData::BufferNotOwned);
 }
 
 void ModuleInternal::SaveScriptCache(const Local<Script> script, const std::string& path) {
-    if (RuntimeConfig.IsDebug) {
-        return;
-    }
-
-    Local<UnboundScript> unboundScript = script->GetUnboundScript();
-    // CachedData returned by this function should be owned by the caller (v8 docs)
-    ScriptCompiler::CachedData* cachedData = ScriptCompiler::CreateCodeCache(unboundScript);
-
-    int length = cachedData->length;
-    std::string cachePath = GetCacheFileName(path + ".cache");
-    tns::WriteBinary(cachePath, cachedData->data, length);
-    delete cachedData;
+  if (RuntimeConfig.IsDebug) {
+    return;
+  }
+
+  Local<UnboundScript> unboundScript = script->GetUnboundScript();
+  // CachedData returned by this function should be owned by the caller (v8 docs)
+  ScriptCompiler::CachedData* cachedData = ScriptCompiler::CreateCodeCache(unboundScript);
+
+  int length = cachedData->length;
+  std::string cachePath = GetCacheFileName(path + ".cache");
+  tns::WriteBinary(cachePath, cachedData->data, length);
+  delete cachedData;
 }
 
 std::string ModuleInternal::GetCacheFileName(const std::string& path) {
-    std::string key = path.substr(RuntimeConfig.ApplicationPath.size() + 1);
-    std::replace(key.begin(), key.end(), '/', '-');
+  std::string key = path.substr(RuntimeConfig.ApplicationPath.size() + 1);
+  std::replace(key.begin(), key.end(), '/', '-');
 
-    NSArray* paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
-    NSString* cachesPath = [paths objectAtIndex:0];
-    NSString* result = [cachesPath stringByAppendingPathComponent:[NSString stringWithUTF8String:key.c_str()]];
+  NSArray* paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+  NSString* cachesPath = [paths objectAtIndex:0];
+  NSString* result =
+      [cachesPath stringByAppendingPathComponent:[NSString stringWithUTF8String:key.c_str()]];
 
-    return [result UTF8String];
+  return [result UTF8String];
 }
 
-}
+}  // namespace tns

From 055b0427cf49e7c4cb37991c9419b899868b6bbd Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@users.noreply.github.com>
Date: Fri, 6 Sep 2024 18:12:18 -0300
Subject: [PATCH 03/11] fix: ensure same mtime for js and code cache to prevent
 loading old code caches (#261)

---
 NativeScript/runtime/ModuleInternal.mm | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/NativeScript/runtime/ModuleInternal.mm b/NativeScript/runtime/ModuleInternal.mm
index cd7aff47..4ade584b 100644
--- a/NativeScript/runtime/ModuleInternal.mm
+++ b/NativeScript/runtime/ModuleInternal.mm
@@ -1,6 +1,8 @@
 #include "ModuleInternal.h"
 #include <Foundation/Foundation.h>
 #include <sys/stat.h>
+#include <time.h>
+#include <utime.h>
 #include <string>
 #include "Caches.h"
 #include "Helpers.h"
@@ -453,9 +455,9 @@ throw NativeScriptException("Unable to locate main entry in " +
     auto cacheLastModifiedTime = result.st_mtime;
     if (stat(path.c_str(), &result) == 0) {
       auto jsLastModifiedTime = result.st_mtime;
-      if (jsLastModifiedTime > 0 && cacheLastModifiedTime > 0 &&
-          jsLastModifiedTime > cacheLastModifiedTime) {
-        // The javascript file is more recent than the cache file => ignore the cache
+      if (jsLastModifiedTime != cacheLastModifiedTime) {
+        // files have different dates, ignore the cache file (this is enforced by the
+        // SaveScriptCache function)
         return nullptr;
       }
     }
@@ -485,6 +487,17 @@ throw NativeScriptException("Unable to locate main entry in " +
   std::string cachePath = GetCacheFileName(path + ".cache");
   tns::WriteBinary(cachePath, cachedData->data, length);
   delete cachedData;
+
+  // make sure cache and js file have the same modification date
+  struct stat result;
+  struct utimbuf new_times;
+  new_times.actime = time(nullptr);
+  new_times.modtime = time(nullptr);
+  if (stat(path.c_str(), &result) == 0) {
+    auto jsLastModifiedTime = result.st_mtime;
+    new_times.modtime = jsLastModifiedTime;
+  }
+  utime(cachePath.c_str(), &new_times);
 }
 
 std::string ModuleInternal::GetCacheFileName(const std::string& path) {

From e6f0c5e670fa0eab2005dcd1bd38cbec9088069d Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Fri, 6 Sep 2024 18:13:38 -0300
Subject: [PATCH 04/11] release: 8.8.2

---
 CHANGELOG.md | 10 ++++++++++
 package.json |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 769e96b6..56c2fc63 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+## [8.8.2](https://github.com/NativeScript/ios/compare/v8.8.1...v8.8.2) (2024-09-06)
+
+
+### Bug Fixes
+
+* ensure same mtime for js and code cache to prevent loading old code caches ([#261](https://github.com/NativeScript/ios/issues/261)) ([055b042](https://github.com/NativeScript/ios/commit/055b0427cf49e7c4cb37991c9419b899868b6bbd))
+* revert visionOS changes to iOS project template ([55c5c51](https://github.com/NativeScript/ios/commit/55c5c5198f04ff2b5cbe1be6f5add92acb3ed23f))
+
+
+
 ## [8.8.1](https://github.com/NativeScript/ios/compare/v8.8.0...v8.8.1) (2024-07-10)
 
 
diff --git a/package.json b/package.json
index 98e21b65..92a034b4 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "8.8.1",
+  "version": "8.8.2",
   "keywords": [
     "NativeScript",
     "iOS",

From 8b932a31fe735c69b9d72b76eb106037653764ce Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Mon, 16 Sep 2024 15:24:01 -0300
Subject: [PATCH 05/11] fix: possible race condition extending native class

---
 NativeScript/runtime/ClassBuilder.cpp | 43 ++++++++++++++++-----------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/NativeScript/runtime/ClassBuilder.cpp b/NativeScript/runtime/ClassBuilder.cpp
index a748e27f..10a820b9 100644
--- a/NativeScript/runtime/ClassBuilder.cpp
+++ b/NativeScript/runtime/ClassBuilder.cpp
@@ -2,27 +2,34 @@
 
 namespace tns {
 
-// Moved this method in a separate .cpp file because ARC destroys the class created with objc_allocateClassPair
-// when the control leaves this method scope
+// Moved this method in a separate .cpp file because ARC destroys the class
+// created with objc_allocateClassPair when the control leaves this method scope
 
-Class ClassBuilder::GetExtendedClass(std::string baseClassName, std::string staticClassName) {
-    Class baseClass = objc_getClass(baseClassName.c_str());
-    std::string name = !staticClassName.empty() ? staticClassName : baseClassName + "_" + std::to_string(++ClassBuilder::classNameCounter_);
-    Class clazz = objc_getClass(name.c_str());
+Class ClassBuilder::GetExtendedClass(std::string baseClassName,
+                                     std::string staticClassName) {
+  Class baseClass = objc_getClass(baseClassName.c_str());
+  std::string name =
+      !staticClassName.empty()
+          ? staticClassName
+          : baseClassName + "_" +
+                std::to_string(++ClassBuilder::classNameCounter_);
+  // here we could either call objc_getClass with the name to see if the class
+  // already exists or we can just try allocating it, which will return nil if
+  // the class already exists so we try allocating it every time to avoid race
+  // conditions in case this method is being executed by multiple threads
+  Class clazz = objc_allocateClassPair(baseClass, name.c_str(), 0);
 
-    if (clazz != nil) {
-        int i = 1;
-        std::string initialName = name;
-        while (clazz != nil) {
-            name = initialName + std::to_string(i++);
-            clazz = objc_getClass(name.c_str());
-        }
+  if (clazz == nil) {
+    int i = 1;
+    std::string initialName = name;
+    while (clazz == nil) {
+      name = initialName + std::to_string(i++);
+      clazz = objc_allocateClassPair(baseClass, name.c_str(), 0);
     }
+  }
 
-    clazz = objc_allocateClassPair(baseClass, name.c_str(), 0);
-
-    objc_registerClassPair(clazz);
-    return clazz;
+  objc_registerClassPair(clazz);
+  return clazz;
 }
 
-}
+}  // namespace tns

From 42190388ddfbd42ad3b87244f5f317860f43c327 Mon Sep 17 00:00:00 2001
From: Igor Randjelovic <rigor789@gmail.com>
Date: Sun, 8 Dec 2024 22:20:08 -0500
Subject: [PATCH 06/11] fix(URL): allow undefined 2nd args and fix pathname
 return value (#263)

---
 NativeScript/runtime/URLImpl.cpp | 49 ++++++++---------
 TestRunner/app/tests/URL.js      | 90 +++++++++++++++++++++-----------
 2 files changed, 83 insertions(+), 56 deletions(-)

diff --git a/NativeScript/runtime/URLImpl.cpp b/NativeScript/runtime/URLImpl.cpp
index 50ca6157..a8c322d9 100644
--- a/NativeScript/runtime/URLImpl.cpp
+++ b/NativeScript/runtime/URLImpl.cpp
@@ -141,6 +141,16 @@ void URLImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
             auto result = ada::parse<ada::url_aggregator>(url_string, &base_url.value());
 
+            if (result) {
+                url = result.value();
+            } else {
+                isolate->ThrowException(
+                        v8::Exception::TypeError(ToV8String(isolate, "")));
+                return;
+            }
+        } else {
+            // treat 2nd arg as undefined otherwise.
+            auto result = ada::parse<ada::url_aggregator>(url_string, nullptr);
             if (result) {
                 url = result.value();
             } else {
@@ -149,7 +159,6 @@ void URLImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
                 return;
             }
         }
-
     } else {
         auto result = ada::parse<ada::url_aggregator>(url_string, nullptr);
         if (result) {
@@ -242,7 +251,6 @@ void URLImpl::GetHostName(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_hostname();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetHostName(v8::Local<v8::String> property,
@@ -271,7 +279,6 @@ void URLImpl::GetHref(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_href();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetHref(v8::Local<v8::String> property,
@@ -299,7 +306,6 @@ void URLImpl::GetOrigin(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_origin();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.c_str()));
-
 }
 
 void URLImpl::GetPassword(v8::Local<v8::String> property,
@@ -314,7 +320,6 @@ void URLImpl::GetPassword(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_password();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetPassword(v8::Local<v8::String> property,
@@ -341,8 +346,7 @@ void URLImpl::GetPathName(v8::Local<v8::String> property,
 
     auto value = ptr->GetURL()->get_pathname();
 
-    info.GetReturnValue().Set(ToV8String(isolate, value.data()));
-
+    info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
 }
 
 void URLImpl::SetPathName(v8::Local<v8::String> property,
@@ -370,7 +374,6 @@ void URLImpl::GetPort(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_port();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetPort(v8::Local<v8::String> property,
@@ -398,7 +401,6 @@ void URLImpl::GetProtocol(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_protocol();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetProtocol(v8::Local<v8::String> property,
@@ -427,7 +429,6 @@ void URLImpl::GetSearch(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_search();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetSearch(v8::Local<v8::String> property,
@@ -456,7 +457,6 @@ void URLImpl::GetUserName(v8::Local<v8::String> property,
     auto value = ptr->GetURL()->get_username();
 
     info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
-
 }
 
 void URLImpl::SetUserName(v8::Local<v8::String> property,
@@ -473,39 +473,36 @@ void URLImpl::SetUserName(v8::Local<v8::String> property,
 }
 
 
-void URLImpl::ToString(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    URLImpl *ptr = GetPointer(args.This());
+void URLImpl::ToString(const v8::FunctionCallbackInfo<v8::Value> &info) {
+    URLImpl *ptr = GetPointer(info.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetEmptyString();
+        info.GetReturnValue().SetEmptyString();
         return;
     }
-    auto isolate = args.GetIsolate();
+    auto isolate = info.GetIsolate();
 
 
     auto value = ptr->GetURL()->get_href();
 
-    auto ret = ToV8String(isolate, value.data(), (int)value.length());
-
-    args.GetReturnValue().Set(ret);
+    info.GetReturnValue().Set(ToV8String(isolate, value.data(), (int)value.length()));
 }
 
 
-void URLImpl::CanParse(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void URLImpl::CanParse(const v8::FunctionCallbackInfo<v8::Value> &info) {
     bool value;
-    auto count = args.Length();
+    auto count = info.Length();
 
-
-    auto isolate = args.GetIsolate();
+    auto isolate = info.GetIsolate();
     if (count > 1) {
-        auto url_string = tns::ToString(isolate, args[0].As<v8::String>());
-        auto base_string = tns::ToString(isolate, args[1].As<v8::String>());
+        auto url_string = tns::ToString(isolate, info[0].As<v8::String>());
+        auto base_string = tns::ToString(isolate, info[1].As<v8::String>());
         std::string_view base_string_view(base_string.data(), base_string.length());
         value = can_parse(url_string, &base_string_view);
     } else {
-        value = can_parse(tns::ToString(isolate, args[0].As<v8::String>()).c_str(), nullptr);
+        value = can_parse(tns::ToString(isolate, info[0].As<v8::String>()).c_str(), nullptr);
     }
 
-    args.GetReturnValue().Set(value);
+    info.GetReturnValue().Set(value);
 }
 
 
diff --git a/TestRunner/app/tests/URL.js b/TestRunner/app/tests/URL.js
index 5ebda35c..245d3b0a 100644
--- a/TestRunner/app/tests/URL.js
+++ b/TestRunner/app/tests/URL.js
@@ -1,31 +1,61 @@
-describe("Test URL ", function () {
-    
-    it("Test invalid URL parsing", function(){
-        var exceptionCaught = false;
-        try {
-            const url = new URL('');
-        }catch(e){
-            exceptionCaught = true;
-        }
-        expect(exceptionCaught).toBe(true);
-    });
-    
-    it("Test valid URL parsing", function(){
-        var exceptionCaught = false;
-        try {
-            const url = new URL('https://google.com');
-        }catch(e){
-            exceptionCaught = true;
-        }
-        expect(exceptionCaught).toBe(false);
-    });
-    
-    
-    it("Test URL fields", function(){
-        var exceptionCaught = false;
-        const url = new URL('https://google.com');
-        expect(url.protocol).toBe('https:');
-        expect(url.hostname).toBe('google.com');
-    });
-    
+describe("URL", function () {
+  it("throws on invalid URL", function () {
+    var exceptionCaught = false;
+    try {
+      const url = new URL("");
+    } catch (e) {
+      exceptionCaught = true;
+    }
+    expect(exceptionCaught).toBe(true);
+  });
+
+  it("does not throw on valid URL", function () {
+    var exceptionCaught = false;
+    try {
+      const url = new URL("https://google.com");
+    } catch (e) {
+      exceptionCaught = true;
+    }
+    expect(exceptionCaught).toBe(false);
+  });
+
+  it("parses simple urls", function () {
+    const url = new URL("https://google.com");
+    expect(url.protocol).toBe("https:");
+    expect(url.hostname).toBe("google.com");
+    expect(url.pathname).toBe("/");
+    expect(url.port).toBe("");
+    expect(url.search).toBe("");
+    expect(url.hash).toBe("");
+    expect(url.username).toBe("");
+    expect(url.password).toBe("");
+    expect(url.origin).toBe("https://google.com");
+    expect(url.searchParams.size).toBe(0);
+  });
+
+  it("parses with undefined base", function () {
+    const url = new URL("https://google.com", undefined);
+    expect(url.protocol).toBe("https:");
+    expect(url.hostname).toBe("google.com");
+  });
+
+  it("parses with null base", function () {
+    const url = new URL("https://google.com", null);
+    expect(url.protocol).toBe("https:");
+    expect(url.hostname).toBe("google.com");
+  });
+
+  it("parses query strings", function () {
+    const url = new URL("https://google.com?q=hello");
+    expect(url.search).toBe("?q=hello");
+    expect(url.searchParams.get("q")).toBe("hello");
+    expect(url.pathname).toBe("/");
+  });
+
+  it("parses query strings with pathname", function () {
+    const url = new URL("https://google.com/some/path?q=hello");
+    expect(url.search).toBe("?q=hello");
+    expect(url.searchParams.get("q")).toBe("hello");
+    expect(url.pathname).toBe("/some/path");
+  });
 });

From 5e8214dc7fffa91abd6c870b294259583ec50ce7 Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@users.noreply.github.com>
Date: Tue, 17 Dec 2024 12:41:11 -0800
Subject: [PATCH 07/11] fix: handle gc protection in runtime run loop (#264)

* fix: handle gc protection in runtime run loop

* release: 8.8.3-alpha.0
---
 CHANGELOG.md                         | 10 ++++
 NativeScript/runtime/ClassBuilder.mm | 83 ++++++++++++++++++++--------
 package.json                         |  2 +-
 3 files changed, 71 insertions(+), 24 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56c2fc63..e7657534 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+## [8.8.3-alpha.0](https://github.com/NativeScript/ios/compare/v8.8.2...v8.8.3-alpha.0) (2024-12-05)
+
+
+### Bug Fixes
+
+* handle gc protection in runtime run loop ([78b5e37](https://github.com/NativeScript/ios/commit/78b5e3799f1305b3eafe7d3deb60a7e56b86b230))
+* possible race condition extending native class ([8b932a3](https://github.com/NativeScript/ios/commit/8b932a31fe735c69b9d72b76eb106037653764ce))
+
+
+
 ## [8.8.2](https://github.com/NativeScript/ios/compare/v8.8.1...v8.8.2) (2024-09-06)
 
 
diff --git a/NativeScript/runtime/ClassBuilder.mm b/NativeScript/runtime/ClassBuilder.mm
index eb106915..308b9430 100644
--- a/NativeScript/runtime/ClassBuilder.mm
+++ b/NativeScript/runtime/ClassBuilder.mm
@@ -268,19 +268,30 @@
                 return retain(self, @selector(retain));
             }
             if ([self retainCount] == 1) {
-                auto innerCache = isolateWrapper.GetCache();
-                auto it = innerCache->Instances.find(self);
-                if (it != innerCache->Instances.end()) {
-                    v8::Locker locker(isolate);
-                    Isolate::Scope isolate_scope(isolate);
-                    HandleScope handle_scope(isolate);
-                    Local<Value> value = it->second->Get(isolate);
-                    BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
-                    if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCObject) {
-                        ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
-                        objcWrapper->GcProtect();
+                auto runtime = Runtime::GetRuntime(isolate);
+                auto runtimeLoop = runtime->RuntimeLoop();
+                void* weakSelf = (__bridge void*) self;
+                auto gcProtect = ^() {
+                    auto innerCache = isolateWrapper.GetCache();
+                    auto it = innerCache->Instances.find((id)weakSelf);
+                    if (it != innerCache->Instances.end()) {
+                        v8::Locker locker(isolate);
+                        Isolate::Scope isolate_scope(isolate);
+                        HandleScope handle_scope(isolate);
+                        Local<Value> value = it->second->Get(isolate);
+                        BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+                        if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCObject) {
+                            ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
+                            objcWrapper->GcProtect();
+                        }
                     }
+                };
+                if(CFRunLoopGetCurrent() != runtimeLoop) {
+                    tns::ExecuteOnRunLoop(runtimeLoop, gcProtect);
+                } else {
+                    gcProtect();
                 }
+                
             }
 
             return retain(self, @selector(retain));
@@ -295,18 +306,44 @@
             }
 
             if ([self retainCount] == 2) {
-                auto innerCache = isolateWrapper.GetCache();
-                auto it = innerCache->Instances.find(self);
-                if (it != innerCache->Instances.end()) {
-                    v8::Locker locker(isolate);
-                    Isolate::Scope isolate_scope(isolate);
-                    HandleScope handle_scope(isolate);
-                    if (it->second != nullptr) {
-                        Local<Value> value = it->second->Get(isolate);
-                        BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
-                        if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCObject) {
-                            ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
-                            objcWrapper->GcUnprotect();
+                void* weakSelf = (__bridge void*) self;
+                auto gcUnprotect = ^() {
+                    
+                    
+                    auto innerCache = isolateWrapper.GetCache();
+                    auto it = innerCache->Instances.find((id)weakSelf);
+                    if (it != innerCache->Instances.end()) {
+                        v8::Locker locker(isolate);
+                        Isolate::Scope isolate_scope(isolate);
+                        HandleScope handle_scope(isolate);
+                        if (it->second != nullptr) {
+                            Local<Value> value = it->second->Get(isolate);
+                            BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+                            if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCObject) {
+                                ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
+                                objcWrapper->GcUnprotect();
+                            }
+                        }
+                    }
+                };
+                auto runtime = Runtime::GetRuntime(isolate);
+                auto runtimeLoop = runtime->RuntimeLoop();
+                if(CFRunLoopGetCurrent() != runtimeLoop) {
+                    tns::ExecuteOnRunLoop(runtimeLoop, gcUnprotect);
+                } else {
+                    auto innerCache = isolateWrapper.GetCache();
+                    auto it = innerCache->Instances.find(self);
+                    if (it != innerCache->Instances.end()) {
+                        v8::Locker locker(isolate);
+                        Isolate::Scope isolate_scope(isolate);
+                        HandleScope handle_scope(isolate);
+                        if (it->second != nullptr) {
+                            Local<Value> value = it->second->Get(isolate);
+                            BaseDataWrapper* wrapper = tns::GetValue(isolate, value);
+                            if (wrapper != nullptr && wrapper->Type() == WrapperType::ObjCObject) {
+                                ObjCDataWrapper* objcWrapper = static_cast<ObjCDataWrapper*>(wrapper);
+                                objcWrapper->GcUnprotect();
+                            }
                         }
                     }
                 }
diff --git a/package.json b/package.json
index 92a034b4..54dad336 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "8.8.2",
+  "version": "8.8.3-alpha.0",
   "keywords": [
     "NativeScript",
     "iOS",

From 59ebb30f7d92d88ff84a1dd0e17cf319f29ca976 Mon Sep 17 00:00:00 2001
From: Nathan Walker <walkerrunpdx@gmail.com>
Date: Fri, 17 Jan 2025 16:18:59 -0800
Subject: [PATCH 08/11] chore: 8.9.0 next

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 54dad336..61054b5a 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "8.8.3-alpha.0",
+  "version": "8.9.0",
   "keywords": [
     "NativeScript",
     "iOS",

From 4e6b5f3f975d2a0380a7962753360429915b033e Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Tue, 17 Dec 2024 15:47:07 -0600
Subject: [PATCH 09/11] chore: format Runtime files

---
 NativeScript/runtime/Runtime.h  | 140 ++++-----
 NativeScript/runtime/Runtime.mm | 513 +++++++++++++++++---------------
 2 files changed, 341 insertions(+), 312 deletions(-)

diff --git a/NativeScript/runtime/Runtime.h b/NativeScript/runtime/Runtime.h
index f52215d9..a55080c4 100644
--- a/NativeScript/runtime/Runtime.h
+++ b/NativeScript/runtime/Runtime.h
@@ -1,91 +1,93 @@
 #ifndef Runtime_h
 #define Runtime_h
 
-#include "libplatform/libplatform.h"
+#include "Caches.h"
 #include "Common.h"
-#include "ModuleInternal.h"
 #include "MetadataBuilder.h"
+#include "ModuleInternal.h"
 #include "SpinLock.h"
-#include "Caches.h"
+#include "libplatform/libplatform.h"
 
 namespace tns {
 
 class Runtime {
-public:
-    Runtime();
-    ~Runtime();
-    v8::Isolate* CreateIsolate();
-    void Init(v8::Isolate* isolate, bool isWorker = false);
-    void RunMainScript();
-    v8::Isolate* GetIsolate();
-
-    const int WorkerId();
-
-    void SetWorkerId(int workerId);
-    inline bool IsRuntimeWorker() {
-        return workerId_ > 0;
-    }
-    
-    inline CFRunLoopRef RuntimeLoop() {
-        return runtimeLoop_;
-    }
+ public:
+  Runtime();
+  ~Runtime();
+  v8::Isolate* CreateIsolate();
+  void Init(v8::Isolate* isolate, bool isWorker = false);
+  void RunMainScript();
+  v8::Isolate* GetIsolate();
 
-    void RunModule(const std::string moduleName);
-    
-    void RunScript(const std::string script);
+  const int WorkerId();
 
-    static void Initialize();
+  void SetWorkerId(int workerId);
+  inline bool IsRuntimeWorker() { return workerId_ > 0; }
 
-    static Runtime* GetCurrentRuntime() {
-        return currentRuntime_;
-    }
-    
-    static Runtime* GetRuntime(v8::Isolate* isolate);
+  inline CFRunLoopRef RuntimeLoop() { return runtimeLoop_; }
 
-    static bool IsWorker() {
-        if (currentRuntime_ == nullptr) {
-            return false;
-        }
+  void RunModule(const std::string moduleName);
 
-        return currentRuntime_->IsRuntimeWorker();
-    }
+  void RunScript(const std::string script);
+
+  static void Initialize();
+
+  static Runtime* GetCurrentRuntime() { return currentRuntime_; }
+
+  static Runtime* GetRuntime(v8::Isolate* isolate);
 
-    static std::shared_ptr<v8::Platform> GetPlatform() {
-        return platform_;
+  static bool IsWorker() {
+    if (currentRuntime_ == nullptr) {
+      return false;
     }
 
-    static id GetAppConfigValue(std::string key);
-
-    static bool IsAlive(const v8::Isolate* isolate);
-private:
-    static thread_local Runtime* currentRuntime_;
-    static std::shared_ptr<v8::Platform> platform_;
-    static std::vector<v8::Isolate*> isolates_;
-    static SpinMutex isolatesMutex_;
-    static bool v8Initialized_;
-    static std::atomic<int> nextIsolateId;
-
-    void DefineGlobalObject(v8::Local<v8::Context> context, bool isWorker);
-    void DefineCollectFunction(v8::Local<v8::Context> context);
-    void DefineNativeScriptVersion(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
-    void DefinePerformanceObject(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
-    void DefineTimeMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
-    void DefineDrainMicrotaskMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
-    void DefineDateTimeConfigurationChangeNotificationMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
-
-    static void PerformanceNowCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
-    v8::Isolate* isolate_;
-    std::unique_ptr<ModuleInternal> moduleInternal_;
-    int workerId_;
-    CFRunLoopRef runtimeLoop_;
-    // TODO: refactor this. This is only needed because, during program termination (UIApplicationMain not called)
-    // the Cache::Workers is released (static initialization order fiasco https://en.cppreference.com/w/cpp/language/siof)
-    // so it released the Cache::Workers shared_ptr and then releases the Runtime unique_ptr
-    // eventually we just need to refactor so that Runtime::Initialize is responsible for its initalization
-    // and lifecycle
-    std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>> workerCache_;
+    return currentRuntime_->IsRuntimeWorker();
+  }
+
+  static std::shared_ptr<v8::Platform> GetPlatform() { return platform_; }
+
+  static id GetAppConfigValue(std::string key);
+
+  static bool IsAlive(const v8::Isolate* isolate);
+
+ private:
+  static thread_local Runtime* currentRuntime_;
+  static std::shared_ptr<v8::Platform> platform_;
+  static std::vector<v8::Isolate*> isolates_;
+  static SpinMutex isolatesMutex_;
+  static bool v8Initialized_;
+  static std::atomic<int> nextIsolateId;
+
+  void DefineGlobalObject(v8::Local<v8::Context> context, bool isWorker);
+  void DefineCollectFunction(v8::Local<v8::Context> context);
+  void DefineNativeScriptVersion(v8::Isolate* isolate,
+                                 v8::Local<v8::ObjectTemplate> globalTemplate);
+  void DefinePerformanceObject(v8::Isolate* isolate,
+                               v8::Local<v8::ObjectTemplate> globalTemplate);
+  void DefineTimeMethod(v8::Isolate* isolate,
+                        v8::Local<v8::ObjectTemplate> globalTemplate);
+  void DefineDrainMicrotaskMethod(v8::Isolate* isolate,
+                                  v8::Local<v8::ObjectTemplate> globalTemplate);
+  void DefineDateTimeConfigurationChangeNotificationMethod(
+      v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
+
+  static void PerformanceNowCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  v8::Isolate* isolate_;
+  std::unique_ptr<ModuleInternal> moduleInternal_;
+  int workerId_;
+  CFRunLoopRef runtimeLoop_;
+  // TODO: refactor this. This is only needed because, during program
+  // termination (UIApplicationMain not called) the Cache::Workers is released
+  // (static initialization order fiasco
+  // https://en.cppreference.com/w/cpp/language/siof) so it released the
+  // Cache::Workers shared_ptr and then releases the Runtime unique_ptr
+  // eventually we just need to refactor so that Runtime::Initialize is
+  // responsible for its initalization and lifecycle
+  std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>
+      workerCache_;
 };
 
-}
+}  // namespace tns
 
 #endif /* Runtime_h */
diff --git a/NativeScript/runtime/Runtime.mm b/NativeScript/runtime/Runtime.mm
index 43e0c029..d34f9359 100644
--- a/NativeScript/runtime/Runtime.mm
+++ b/NativeScript/runtime/Runtime.mm
@@ -1,26 +1,26 @@
-#include <string>
-#include <chrono>
 #include "Runtime.h"
+#include <chrono>
+#include <string>
+#include "ArgConverter.h"
 #include "Caches.h"
 #include "Console.h"
-#include "ArgConverter.h"
+#include "Constants.h"
+#include "Helpers.h"
+#include "InlineFunctions.h"
 #include "Interop.h"
 #include "NativeScriptException.h"
-#include "InlineFunctions.h"
-#include "SimpleAllocator.h"
 #include "ObjectManager.h"
-#include "RuntimeConfig.h"
 #include "PromiseProxy.h"
-#include "Helpers.h"
+#include "RuntimeConfig.h"
+#include "SimpleAllocator.h"
+#include "SpinLock.h"
 #include "TSHelpers.h"
 #include "WeakRef.h"
 #include "Worker.h"
-#include "Constants.h"
-#include "SpinLock.h"
 // #include "SetTimeout.h"
 
-#include "IsolateWrapper.h"
 #include "DisposerPHV.h"
+#include "IsolateWrapper.h"
 
 #include "ModuleBinding.hpp"
 #include "URLImpl.h"
@@ -38,8 +38,9 @@
 SimpleAllocator allocator_;
 NSDictionary* AppPackageJson = nil;
 
-// TODO: consider listening to timezone changes and automatically reseting the DateTime. Probably makes more sense to move it to its own file
-//void UpdateTimezoneNotificationCallback(CFNotificationCenterRef center,
+// TODO: consider listening to timezone changes and automatically reseting the DateTime. Probably
+// makes more sense to move it to its own file
+// void UpdateTimezoneNotificationCallback(CFNotificationCenterRef center,
 //                void *observer,
 //                CFStringRef name,
 //                const void *object,
@@ -53,153 +54,158 @@
 //    });
 //}
 // add this to register (most likely on setting up isolate
-//CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(), this, &UpdateTimezoneNotificationCallback, kCFTimeZoneSystemTimeZoneDidChangeNotification, nullptr, CFNotificationSuspensionBehaviorDeliverImmediately);
+// CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(), this,
+// &UpdateTimezoneNotificationCallback, kCFTimeZoneSystemTimeZoneDidChangeNotification, nullptr,
+// CFNotificationSuspensionBehaviorDeliverImmediately);
 // add this to remove the observer
-//CFNotificationCenterRemoveObserver(CFNotificationCenterGetLocalCenter(), this, kCFTimeZoneSystemTimeZoneDidChangeNotification, NULL);
+// CFNotificationCenterRemoveObserver(CFNotificationCenterGetLocalCenter(), this,
+// kCFTimeZoneSystemTimeZoneDidChangeNotification, NULL);
 
 void DisposeIsolateWhenPossible(Isolate* isolate) {
-    // most of the time, this will never delay disposal
-    // occasionally this can happen when the runtime is destroyed by actions of its own isolate
-    // as an example: isolate calls exit(0), which in turn destroys the Runtime unique_ptr
-    // another scenario is when embedding nativescript, if the embedder deletes the runtime as a result of a callback from JS
-    // in the case of exit(0), the app will die before actually disposing the isolate, which isn't a problem
-    if (isolate->IsInUse()) {
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10.0 * NSEC_PER_MSEC)),
-                       dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
-            DisposeIsolateWhenPossible(isolate);
-        });
-    } else {
-        isolate->Dispose();
-    }
+  // most of the time, this will never delay disposal
+  // occasionally this can happen when the runtime is destroyed by actions of its own isolate
+  // as an example: isolate calls exit(0), which in turn destroys the Runtime unique_ptr
+  // another scenario is when embedding nativescript, if the embedder deletes the runtime as a
+  // result of a callback from JS in the case of exit(0), the app will die before actually disposing
+  // the isolate, which isn't a problem
+  if (isolate->IsInUse()) {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10.0 * NSEC_PER_MSEC)),
+                   dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+                     DisposeIsolateWhenPossible(isolate);
+                   });
+  } else {
+    isolate->Dispose();
+  }
 }
 
-void Runtime::Initialize() {
-    MetaFile::setInstance(RuntimeConfig.MetadataPtr);
-}
+void Runtime::Initialize() { MetaFile::setInstance(RuntimeConfig.MetadataPtr); }
 
 Runtime::Runtime() {
-    currentRuntime_ = this;
-    workerId_ = -1;
-    workerCache_ = Caches::Workers;
+  currentRuntime_ = this;
+  workerId_ = -1;
+  workerCache_ = Caches::Workers;
 }
 
 Runtime::~Runtime() {
-    auto currentIsolate = this->isolate_;
-    {
-        // make sure we remove the isolate from the list of active isolates first
-        // this will make sure isAlive(isolate) will return false and prevent locking of the v8 isolate after
-        // it terminates execution
-        SpinLock lock(isolatesMutex_);
-        Runtime::isolates_.erase(std::remove(Runtime::isolates_.begin(), Runtime::isolates_.end(), this->isolate_), Runtime::isolates_.end());
-        Caches::Get(isolate_)->InvalidateIsolate();
+  auto currentIsolate = this->isolate_;
+  {
+    // make sure we remove the isolate from the list of active isolates first
+    // this will make sure isAlive(isolate) will return false and prevent locking of the v8 isolate
+    // after it terminates execution
+    SpinLock lock(isolatesMutex_);
+    Runtime::isolates_.erase(
+        std::remove(Runtime::isolates_.begin(), Runtime::isolates_.end(), this->isolate_),
+        Runtime::isolates_.end());
+    Caches::Get(isolate_)->InvalidateIsolate();
+  }
+  this->isolate_->TerminateExecution();
+
+  // TODO: fix race condition on workers where a queue can leak (maybe calling Terminate before
+  // Initialize?)
+  Caches::Workers->ForEach([currentIsolate](int& key, std::shared_ptr<Caches::WorkerState>& value) {
+    auto childWorkerWrapper = static_cast<WorkerWrapper*>(value->UserData());
+    if (childWorkerWrapper->GetMainIsolate() == currentIsolate) {
+      childWorkerWrapper->Terminate();
     }
-    this->isolate_->TerminateExecution();
-    
-    // TODO: fix race condition on workers where a queue can leak (maybe calling Terminate before Initialize?)
-    Caches::Workers->ForEach([currentIsolate](int& key, std::shared_ptr<Caches::WorkerState>& value) {
-        auto childWorkerWrapper = static_cast<WorkerWrapper*>(value->UserData());
-        if (childWorkerWrapper->GetMainIsolate() == currentIsolate) {
-            childWorkerWrapper->Terminate();
-        }
-        return false;
-    });
+    return false;
+  });
+
+  {
+    v8::Locker lock(isolate_);
+    DisposerPHV phv(isolate_);
+    isolate_->VisitHandlesWithClassIds(&phv);
+
+    if (IsRuntimeWorker()) {
+      auto currentWorker =
+          static_cast<WorkerWrapper*>(Caches::Workers->Get(this->workerId_)->UserData());
+      Caches::Workers->Remove(this->workerId_);
+      // if the parent isolate is dead then deleting the wrapper is our responsibility
+      if (currentWorker->IsWeak()) {
+        delete currentWorker;
+      }
+    }
+    Caches::Remove(this->isolate_);
 
-    {
-        v8::Locker lock(isolate_);
-        DisposerPHV phv(isolate_);
-        isolate_->VisitHandlesWithClassIds( &phv );
-        
-        if (IsRuntimeWorker()) {
-            auto currentWorker = static_cast<WorkerWrapper*>(Caches::Workers->Get(this->workerId_)->UserData());
-            Caches::Workers->Remove(this->workerId_);
-            // if the parent isolate is dead then deleting the wrapper is our responsibility
-            if (currentWorker->IsWeak()) {
-                delete currentWorker;
-            }
-        }
-        Caches::Remove(this->isolate_);
+    this->isolate_->SetData(Constants::RUNTIME_SLOT, nullptr);
+  }
 
-        this->isolate_->SetData(Constants::RUNTIME_SLOT, nullptr);
-    }
+  DisposeIsolateWhenPossible(this->isolate_);
 
-    DisposeIsolateWhenPossible(this->isolate_);
-    
-    currentRuntime_ = nullptr;
+  currentRuntime_ = nullptr;
 }
 
 Runtime* Runtime::GetRuntime(v8::Isolate* isolate) {
-    return  static_cast<Runtime*>(isolate->GetData(Constants::RUNTIME_SLOT));
+  return static_cast<Runtime*>(isolate->GetData(Constants::RUNTIME_SLOT));
 }
 
 Isolate* Runtime::CreateIsolate() {
-    if (!v8Initialized_) {
-        // Runtime::platform_ = RuntimeConfig.IsDebug
+  if (!v8Initialized_) {
+    // Runtime::platform_ = RuntimeConfig.IsDebug
     //     ? v8_inspector::V8InspectorPlatform::CreateDefaultPlatform()
     //     : platform::NewDefaultPlatform();
 
-        Runtime::platform_ = platform::NewDefaultPlatform();
+    Runtime::platform_ = platform::NewDefaultPlatform();
 
-        V8::InitializePlatform(Runtime::platform_.get());
-        V8::Initialize();
-        std::string flags = RuntimeConfig.IsDebug
-        ? "--expose_gc --jitless"
-        : "--expose_gc --jitless --no-lazy";
-        V8::SetFlagsFromString(flags.c_str(), flags.size());
-        v8Initialized_ = true;
-    }
-    
-    // auto version = v8::V8::GetVersion();
-
-    Isolate::CreateParams create_params;
-    create_params.array_buffer_allocator = &allocator_;
-    Isolate* isolate = Isolate::New(create_params);
-    runtimeLoop_ = CFRunLoopGetCurrent();
-    isolate->SetData(Constants::RUNTIME_SLOT, this);
-
-    {
-        SpinLock lock(isolatesMutex_);
-        Runtime::isolates_.emplace_back(isolate);
-    }
+    V8::InitializePlatform(Runtime::platform_.get());
+    V8::Initialize();
+    std::string flags =
+        RuntimeConfig.IsDebug ? "--expose_gc --jitless" : "--expose_gc --jitless --no-lazy";
+    V8::SetFlagsFromString(flags.c_str(), flags.size());
+    v8Initialized_ = true;
+  }
+
+  // auto version = v8::V8::GetVersion();
+
+  Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = &allocator_;
+  Isolate* isolate = Isolate::New(create_params);
+  runtimeLoop_ = CFRunLoopGetCurrent();
+  isolate->SetData(Constants::RUNTIME_SLOT, this);
+
+  {
+    SpinLock lock(isolatesMutex_);
+    Runtime::isolates_.emplace_back(isolate);
+  }
 
-    return isolate;
+  return isolate;
 }
 
 void Runtime::Init(Isolate* isolate, bool isWorker) {
-    std::shared_ptr<Caches> cache = Caches::Init(isolate, nextIsolateId.fetch_add(1, std::memory_order_relaxed));
-    cache->isWorker = isWorker;
-    cache->ObjectCtorInitializer = MetadataBuilder::GetOrCreateConstructorFunctionTemplate;
-    cache->StructCtorInitializer = MetadataBuilder::GetOrCreateStructCtorFunction;
-
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-    Local<FunctionTemplate> globalTemplateFunction = FunctionTemplate::New(isolate);
-    globalTemplateFunction->SetClassName(tns::ToV8String(isolate, "NativeScriptGlobalObject"));
-    tns::binding::CreateInternalBindingTemplates(isolate, globalTemplateFunction);
-    Local<ObjectTemplate> globalTemplate = ObjectTemplate::New(isolate, globalTemplateFunction);
-    DefineNativeScriptVersion(isolate, globalTemplate);
-
-    //Worker::Init(isolate, globalTemplate, isWorker);
-    DefinePerformanceObject(isolate, globalTemplate);
-    DefineTimeMethod(isolate, globalTemplate);
-    DefineDrainMicrotaskMethod(isolate, globalTemplate);
-    ObjectManager::Init(isolate, globalTemplate);
-//    SetTimeout::Init(isolate, globalTemplate);
-    MetadataBuilder::RegisterConstantsOnGlobalObject(isolate, globalTemplate, isWorker);
-
-    isolate->SetCaptureStackTraceForUncaughtExceptions(true, 100, StackTrace::kOverview);
-    isolate->AddMessageListener(NativeScriptException::OnUncaughtError);
-
-    Local<Context> context = Context::New(isolate, nullptr, globalTemplate);
-    context->Enter();
-
-    DefineGlobalObject(context, isWorker);
-    DefineCollectFunction(context);
-    PromiseProxy::Init(context);
-    Console::Init(context);
-    WeakRef::Init(context);
-    
-    
-    auto blob_methods = R"js(
+  std::shared_ptr<Caches> cache =
+      Caches::Init(isolate, nextIsolateId.fetch_add(1, std::memory_order_relaxed));
+  cache->isWorker = isWorker;
+  cache->ObjectCtorInitializer = MetadataBuilder::GetOrCreateConstructorFunctionTemplate;
+  cache->StructCtorInitializer = MetadataBuilder::GetOrCreateStructCtorFunction;
+
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  Local<FunctionTemplate> globalTemplateFunction = FunctionTemplate::New(isolate);
+  globalTemplateFunction->SetClassName(tns::ToV8String(isolate, "NativeScriptGlobalObject"));
+  tns::binding::CreateInternalBindingTemplates(isolate, globalTemplateFunction);
+  Local<ObjectTemplate> globalTemplate = ObjectTemplate::New(isolate, globalTemplateFunction);
+  DefineNativeScriptVersion(isolate, globalTemplate);
+
+  // Worker::Init(isolate, globalTemplate, isWorker);
+  DefinePerformanceObject(isolate, globalTemplate);
+  DefineTimeMethod(isolate, globalTemplate);
+  DefineDrainMicrotaskMethod(isolate, globalTemplate);
+  ObjectManager::Init(isolate, globalTemplate);
+  //    SetTimeout::Init(isolate, globalTemplate);
+  MetadataBuilder::RegisterConstantsOnGlobalObject(isolate, globalTemplate, isWorker);
+
+  isolate->SetCaptureStackTraceForUncaughtExceptions(true, 100, StackTrace::kOverview);
+  isolate->AddMessageListener(NativeScriptException::OnUncaughtError);
+
+  Local<Context> context = Context::New(isolate, nullptr, globalTemplate);
+  context->Enter();
+
+  DefineGlobalObject(context, isWorker);
+  DefineCollectFunction(context);
+  PromiseProxy::Init(context);
+  Console::Init(context);
+  WeakRef::Init(context);
+
+  auto blob_methods = R"js(
     const BLOB_STORE = new Map();
     URL.createObjectURL = function (object, options = null) {
         try {
@@ -260,170 +266,191 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
         },
     });
     )js";
-    
-    
-    v8::Local<v8::Script> script;
-    auto done = v8::Script::Compile(context, ToV8String(isolate, blob_methods)).ToLocal(&script);
-    
-    v8::Local<v8::Value> outVal;
-    if(done){
-        done = script->Run(context).ToLocal(&outVal);
-    }
-      
-    
 
-    this->moduleInternal_ = std::make_unique<ModuleInternal>(context);
+  v8::Local<v8::Script> script;
+  auto done = v8::Script::Compile(context, ToV8String(isolate, blob_methods)).ToLocal(&script);
+
+  v8::Local<v8::Value> outVal;
+  if (done) {
+    done = script->Run(context).ToLocal(&outVal);
+  }
+
+  this->moduleInternal_ = std::make_unique<ModuleInternal>(context);
 
-    ArgConverter::Init(context, MetadataBuilder::StructPropertyGetterCallback, MetadataBuilder::StructPropertySetterCallback);
-    Interop::RegisterInteropTypes(context);
+  ArgConverter::Init(context, MetadataBuilder::StructPropertyGetterCallback,
+                     MetadataBuilder::StructPropertySetterCallback);
+  Interop::RegisterInteropTypes(context);
 
-    ClassBuilder::RegisterBaseTypeScriptExtendsFunction(context); // Register the __extends function to the global object
-    ClassBuilder::RegisterNativeTypeScriptExtendsFunction(context); // Override the __extends function for native objects
-    TSHelpers::Init(context);
+  ClassBuilder::RegisterBaseTypeScriptExtendsFunction(
+      context);  // Register the __extends function to the global object
+  ClassBuilder::RegisterNativeTypeScriptExtendsFunction(
+      context);  // Override the __extends function for native objects
+  TSHelpers::Init(context);
 
-    InlineFunctions::Init(context);
+  InlineFunctions::Init(context);
 
-    cache->SetContext(context);
+  cache->SetContext(context);
 
-    this->isolate_ = isolate;
+  this->isolate_ = isolate;
 }
 
 void Runtime::RunMainScript() {
-    Isolate* isolate = this->GetIsolate();
-    v8::Locker locker(isolate);
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-    this->moduleInternal_->RunModule(isolate, "./");
+  Isolate* isolate = this->GetIsolate();
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  this->moduleInternal_->RunModule(isolate, "./");
 }
 
 void Runtime::RunModule(const std::string moduleName) {
-    Isolate* isolate = this->GetIsolate();
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-    this->moduleInternal_->RunModule(isolate, moduleName);
+  Isolate* isolate = this->GetIsolate();
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  this->moduleInternal_->RunModule(isolate, moduleName);
 }
 
 void Runtime::RunScript(const std::string script) {
-    Isolate* isolate = this->GetIsolate();
-    v8::Locker locker(isolate);
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-    this->moduleInternal_->RunScript(isolate, script);
+  Isolate* isolate = this->GetIsolate();
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  this->moduleInternal_->RunScript(isolate, script);
 }
 
+Isolate* Runtime::GetIsolate() { return this->isolate_; }
 
-Isolate* Runtime::GetIsolate() {
-    return this->isolate_;
-}
+const int Runtime::WorkerId() { return this->workerId_; }
 
-const int Runtime::WorkerId() {
-    return this->workerId_;
-}
-
-void Runtime::SetWorkerId(int workerId) {
-    this->workerId_ = workerId;
-}
+void Runtime::SetWorkerId(int workerId) { this->workerId_ = workerId; }
 
 id Runtime::GetAppConfigValue(std::string key) {
-    if (AppPackageJson == nil) {
-        NSString* packageJsonPath = [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()] stringByAppendingPathComponent:@"package.json"];
-        NSData* data = [NSData dataWithContentsOfFile:packageJsonPath];
-        if (data) {
-            NSError* error = nil;
-            NSDictionary* dict = [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:&error];
-            AppPackageJson = [[NSDictionary alloc] initWithDictionary:dict];
-        }
+  if (AppPackageJson == nil) {
+    NSString* packageJsonPath =
+        [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()]
+            stringByAppendingPathComponent:@"package.json"];
+    NSData* data = [NSData dataWithContentsOfFile:packageJsonPath];
+    if (data) {
+      NSError* error = nil;
+      NSDictionary* dict = [NSJSONSerialization JSONObjectWithData:data
+                                                           options:kNilOptions
+                                                             error:&error];
+      AppPackageJson = [[NSDictionary alloc] initWithDictionary:dict];
     }
+  }
 
-    id result = AppPackageJson[[NSString stringWithUTF8String:key.c_str()]];
-    return result;
+  id result = AppPackageJson[[NSString stringWithUTF8String:key.c_str()]];
+  return result;
 }
 
 void Runtime::DefineGlobalObject(Local<Context> context, bool isWorker) {
-    Isolate* isolate = context->GetIsolate();
-    Local<Object> global = context->Global();
-    const PropertyAttribute readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
-    if (!global->DefineOwnProperty(context, ToV8String(context->GetIsolate(), "global"), global, readOnlyFlags).FromMaybe(false)) {
-        tns::Assert(false, isolate);
-    }
-
-    if (isWorker && !global->DefineOwnProperty(context, ToV8String(context->GetIsolate(), "self"), global, readOnlyFlags).FromMaybe(false)) {
-        tns::Assert(false, isolate);
-    }
+  Isolate* isolate = context->GetIsolate();
+  Local<Object> global = context->Global();
+  const PropertyAttribute readOnlyFlags =
+      static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+  if (!global
+           ->DefineOwnProperty(context, ToV8String(context->GetIsolate(), "global"), global,
+                               readOnlyFlags)
+           .FromMaybe(false)) {
+    tns::Assert(false, isolate);
+  }
+
+  if (isWorker && !global
+                       ->DefineOwnProperty(context, ToV8String(context->GetIsolate(), "self"),
+                                           global, readOnlyFlags)
+                       .FromMaybe(false)) {
+    tns::Assert(false, isolate);
+  }
 }
 
 void Runtime::DefineCollectFunction(Local<Context> context) {
-    Isolate* isolate = context->GetIsolate();
-    Local<Object> global = context->Global();
-    Local<Value> value;
-    bool success = global->Get(context, tns::ToV8String(isolate, "gc")).ToLocal(&value);
-    tns::Assert(success, isolate);
-
-    if (value.IsEmpty() || !value->IsFunction()) {
-        return;
-    }
-
-    Local<v8::Function> gcFunc = value.As<v8::Function>();
-    const PropertyAttribute readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
-    success = global->DefineOwnProperty(context, tns::ToV8String(isolate, "__collect"), gcFunc, readOnlyFlags).FromMaybe(false);
-    tns::Assert(success, isolate);
+  Isolate* isolate = context->GetIsolate();
+  Local<Object> global = context->Global();
+  Local<Value> value;
+  bool success = global->Get(context, tns::ToV8String(isolate, "gc")).ToLocal(&value);
+  tns::Assert(success, isolate);
+
+  if (value.IsEmpty() || !value->IsFunction()) {
+    return;
+  }
+
+  Local<v8::Function> gcFunc = value.As<v8::Function>();
+  const PropertyAttribute readOnlyFlags =
+      static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+  success =
+      global
+          ->DefineOwnProperty(context, tns::ToV8String(isolate, "__collect"), gcFunc, readOnlyFlags)
+          .FromMaybe(false);
+  tns::Assert(success, isolate);
 }
 
 void Runtime::DefinePerformanceObject(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {
-    Local<ObjectTemplate> performanceTemplate = ObjectTemplate::New(isolate);
+  Local<ObjectTemplate> performanceTemplate = ObjectTemplate::New(isolate);
 
-    Local<FunctionTemplate> nowFuncTemplate = FunctionTemplate::New(isolate, PerformanceNowCallback);
-    performanceTemplate->Set(tns::ToV8String(isolate, "now"), nowFuncTemplate);
+  Local<FunctionTemplate> nowFuncTemplate = FunctionTemplate::New(isolate, PerformanceNowCallback);
+  performanceTemplate->Set(tns::ToV8String(isolate, "now"), nowFuncTemplate);
 
-    Local<v8::String> performancePropertyName = ToV8String(isolate, "performance");
-    globalTemplate->Set(performancePropertyName, performanceTemplate);
+  Local<v8::String> performancePropertyName = ToV8String(isolate, "performance");
+  globalTemplate->Set(performancePropertyName, performanceTemplate);
 }
 
 void Runtime::PerformanceNowCallback(const FunctionCallbackInfo<Value>& args) {
-    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
-    std::chrono::milliseconds timestampMs = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
-    double result = timestampMs.count();
-    args.GetReturnValue().Set(result);
+  std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+  std::chrono::milliseconds timestampMs =
+      std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
+  double result = timestampMs.count();
+  args.GetReturnValue().Set(result);
 }
 
 void Runtime::DefineNativeScriptVersion(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {
-    const PropertyAttribute readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
-    globalTemplate->Set(ToV8String(isolate, "__runtimeVersion"), ToV8String(isolate, STRINGIZE_VALUE_OF(NATIVESCRIPT_VERSION)), readOnlyFlags);
+  const PropertyAttribute readOnlyFlags =
+      static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+  globalTemplate->Set(ToV8String(isolate, "__runtimeVersion"),
+                      ToV8String(isolate, STRINGIZE_VALUE_OF(NATIVESCRIPT_VERSION)), readOnlyFlags);
 }
 
 void Runtime::DefineTimeMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate) {
-    Local<FunctionTemplate> timeFunctionTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
-        auto nano = std::chrono::time_point_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now());
+  Local<FunctionTemplate> timeFunctionTemplate =
+      FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
+        auto nano = std::chrono::time_point_cast<std::chrono::nanoseconds>(
+            std::chrono::steady_clock::now());
         double duration = nano.time_since_epoch().count() / 1000000.0;
         info.GetReturnValue().Set(duration);
-    });
-    globalTemplate->Set(ToV8String(isolate, "__time"), timeFunctionTemplate);
+      });
+  globalTemplate->Set(ToV8String(isolate, "__time"), timeFunctionTemplate);
 }
 
-void Runtime::DefineDrainMicrotaskMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate) {
-    Local<FunctionTemplate> drainMicrotaskTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
+void Runtime::DefineDrainMicrotaskMethod(v8::Isolate* isolate,
+                                         v8::Local<v8::ObjectTemplate> globalTemplate) {
+  Local<FunctionTemplate> drainMicrotaskTemplate =
+      FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
         info.GetIsolate()->PerformMicrotaskCheckpoint();
-    });
-    globalTemplate->Set(ToV8String(isolate, "__drainMicrotaskQueue"), drainMicrotaskTemplate);
+      });
+  globalTemplate->Set(ToV8String(isolate, "__drainMicrotaskQueue"), drainMicrotaskTemplate);
 }
 
-void Runtime::DefineDateTimeConfigurationChangeNotificationMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate) {
-    Local<FunctionTemplate> drainMicrotaskTemplate = FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
-        info.GetIsolate()->DateTimeConfigurationChangeNotification(Isolate::TimeZoneDetection::kRedetect);
-    });
-    globalTemplate->Set(ToV8String(isolate, "__dateTimeConfigurationChangeNotification"), drainMicrotaskTemplate);
+void Runtime::DefineDateTimeConfigurationChangeNotificationMethod(
+    v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate) {
+  Local<FunctionTemplate> drainMicrotaskTemplate =
+      FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
+        info.GetIsolate()->DateTimeConfigurationChangeNotification(
+            Isolate::TimeZoneDetection::kRedetect);
+      });
+  globalTemplate->Set(ToV8String(isolate, "__dateTimeConfigurationChangeNotification"),
+                      drainMicrotaskTemplate);
 }
 
 bool Runtime::IsAlive(const Isolate* isolate) {
-    // speedup lookup by avoiding locking if thread locals match
-    // note: this can be a problem when the Runtime is deleted in a different thread that it was created
-    // which could happen under some specific embedding scenarios
-    if ((Isolate::TryGetCurrent() == isolate || (currentRuntime_ != nullptr && currentRuntime_->GetIsolate() == isolate))
-        && Caches::Get((Isolate*)isolate)->IsValid()) {
-        return true;
-    }
-    SpinLock lock(isolatesMutex_);
-    return std::find(Runtime::isolates_.begin(), Runtime::isolates_.end(), isolate) != Runtime::isolates_.end();
+  // speedup lookup by avoiding locking if thread locals match
+  // note: this can be a problem when the Runtime is deleted in a different thread that it was
+  // created which could happen under some specific embedding scenarios
+  if ((Isolate::TryGetCurrent() == isolate ||
+       (currentRuntime_ != nullptr && currentRuntime_->GetIsolate() == isolate)) &&
+      Caches::Get((Isolate*)isolate)->IsValid()) {
+    return true;
+  }
+  SpinLock lock(isolatesMutex_);
+  return std::find(Runtime::isolates_.begin(), Runtime::isolates_.end(), isolate) !=
+         Runtime::isolates_.end();
 }
 
 std::shared_ptr<Platform> Runtime::platform_;
@@ -432,4 +459,4 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
 thread_local Runtime* Runtime::currentRuntime_ = nullptr;
 SpinMutex Runtime::isolatesMutex_;
 
-}
+}  // namespace tns

From 8b320a4b15a216d27d43acfda44cd068d84f6e65 Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Tue, 17 Dec 2024 15:48:48 -0600
Subject: [PATCH 10/11] feat: use monotonic time for performance object

---
 NativeScript/runtime/Runtime.h  |  2 ++
 NativeScript/runtime/Runtime.mm | 14 +++++++++-----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/NativeScript/runtime/Runtime.h b/NativeScript/runtime/Runtime.h
index a55080c4..5a7de0e1 100644
--- a/NativeScript/runtime/Runtime.h
+++ b/NativeScript/runtime/Runtime.h
@@ -77,6 +77,8 @@ class Runtime {
   std::unique_ptr<ModuleInternal> moduleInternal_;
   int workerId_;
   CFRunLoopRef runtimeLoop_;
+  double startTime;
+  double realtimeOrigin;
   // TODO: refactor this. This is only needed because, during program
   // termination (UIApplicationMain not called) the Cache::Workers is released
   // (static initialization order fiasco
diff --git a/NativeScript/runtime/Runtime.mm b/NativeScript/runtime/Runtime.mm
index d34f9359..e9f1a0d1 100644
--- a/NativeScript/runtime/Runtime.mm
+++ b/NativeScript/runtime/Runtime.mm
@@ -154,6 +154,9 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
     v8Initialized_ = true;
   }
 
+  startTime = platform_->MonotonicallyIncreasingTime();
+  realtimeOrigin = platform_->CurrentClockTimeMillis();
+
   // auto version = v8::V8::GetVersion();
 
   Isolate::CreateParams create_params;
@@ -389,16 +392,17 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
   Local<FunctionTemplate> nowFuncTemplate = FunctionTemplate::New(isolate, PerformanceNowCallback);
   performanceTemplate->Set(tns::ToV8String(isolate, "now"), nowFuncTemplate);
 
+  performanceTemplate->Set(tns::ToV8String(isolate, "timeOrigin"),
+                           v8::Number::New(isolate, realtimeOrigin));
+
   Local<v8::String> performancePropertyName = ToV8String(isolate, "performance");
   globalTemplate->Set(performancePropertyName, performanceTemplate);
 }
 
 void Runtime::PerformanceNowCallback(const FunctionCallbackInfo<Value>& args) {
-  std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
-  std::chrono::milliseconds timestampMs =
-      std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
-  double result = timestampMs.count();
-  args.GetReturnValue().Set(result);
+  auto runtime = Runtime::GetRuntime(args.GetIsolate());
+  args.GetReturnValue().Set(
+      (runtime->platform_->MonotonicallyIncreasingTime() - runtime->startTime) * 1000.0);
 }
 
 void Runtime::DefineNativeScriptVersion(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {

From b73693a52bc53c00dd130ff3a69eec523426de4d Mon Sep 17 00:00:00 2001
From: Eduardo Speroni <edusperoni@gmail.com>
Date: Tue, 17 Dec 2024 15:59:12 -0600
Subject: [PATCH 11/11] test: add performance object test

---
 .../app/tests/RuntimeImplementedAPIs.js       | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/TestRunner/app/tests/RuntimeImplementedAPIs.js b/TestRunner/app/tests/RuntimeImplementedAPIs.js
index f9b1b6ba..fe3bf575 100644
--- a/TestRunner/app/tests/RuntimeImplementedAPIs.js
+++ b/TestRunner/app/tests/RuntimeImplementedAPIs.js
@@ -16,3 +16,31 @@ describe("Runtime exposes", function () {
     expect(Math.abs(dateDelta - timeDelta)).toBeLessThan(dateDelta * 0.25);
   });
 });
+
+describe("Performance object", () => {
+  it("should be available", () => {
+    expect(performance).toBeDefined();
+  });
+  it("should have a now function", () => {
+    expect(performance.now).toBeDefined();
+  });
+  it("should have a now function that returns a number", () => {
+    expect(typeof performance.now()).toBe("number");
+  });
+  it("should have timeOrigin", () => {
+    expect(performance.timeOrigin).toBeDefined();
+  });
+  it("should have timeOrigin that is a number", () => {
+    expect(typeof performance.timeOrigin).toBe("number");
+  });
+  it("should have timeOrigin that is greater than 0", () => {
+    expect(performance.timeOrigin).toBeGreaterThan(0);
+  });
+  it("should be close to the current time", () => {
+    const dateNow = Date.now();
+    const performanceNow = performance.now();
+    const timeOrigin = performance.timeOrigin;
+    const performanceAccurateNow = timeOrigin + performanceNow;
+    expect(Math.abs(dateNow - performanceAccurateNow)).toBeLessThan(10);
+  });
+});