@triniwiz/nativescript-masonkit 1.0.0-alpha.5 → 1.0.0-alpha.7

package/pods/Headers/runtime/MetadataBuilder.h

@@ -0,0 +1,72 @@
+#ifndef MetadataBuilder_h
+#define MetadataBuilder_h
+
+#include "robin_hood.h"
+#include "libffi.h"
+#include "Common.h"
+#include "Metadata.h"
+#include "ClassBuilder.h"
+#include "DataWrapper.h"
+
+namespace tns {
+
+class MetadataBuilder {
+public:
+    static void RegisterConstantsOnGlobalObject(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate, bool isWorkerThread);
+    static v8::Local<v8::FunctionTemplate> GetOrCreateConstructorFunctionTemplate(v8::Local<v8::Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
+    static v8::Local<v8::Function> GetOrCreateStructCtorFunction(v8::Local<v8::Context> context, StructInfo structInfo);
+    static void StructPropertyGetterCallback(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info);
+    static void StructPropertySetterCallback(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info);
+private:
+    static v8::Local<v8::FunctionTemplate> GetOrCreateConstructorFunctionTemplateInternal(v8::Local<v8::Context> context, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& instanceMembers, robin_hood::unordered_map<std::string, uint8_t>& staticMembers, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
+    static void GlobalPropertyGetter(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info);
+    static void ClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void AllocCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void CFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void PropertyGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void PropertySetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void PropertyNameGetterCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void PropertyNameSetterCallback(v8::Local<v8::Name> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void> &info);
+    static void StructConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void StructEqualsCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void ToStringFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static std::pair<ffi_type*, void*> GetStructData(v8::Local<v8::Context> context, v8::Local<v8::Object> initializer, StructInfo structInfo);
+
+    static v8::Local<v8::Value> InvokeMethod(v8::Local<v8::Context> context, const MethodMeta* meta, v8::Local<v8::Object> receiver, V8Args& args, std::string containingClass, bool isMethodCallback);
+    static void RegisterAllocMethod(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const InterfaceMeta* interfaceMeta);
+    static void RegisterInstanceMethods(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void RegisterInstanceProperties(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void RegisterInstanceProtocols(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, const BaseClassMeta* meta, std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void RegisterAdditionalProtocols(v8::Local<v8::Context> context, v8::Local<v8::FunctionTemplate> ctorFuncTemplate, KnownUnknownClassPair pair, const std::vector<std::string>& additionalProtocols, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void RegisterStaticMethods(v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc, const BaseClassMeta* meta, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void RegisterStaticProperties(v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void RegisterStaticProtocols(v8::Local<v8::Context> context, v8::Local<v8::Function> ctorFunc, const BaseClassMeta* meta, const std::string className, KnownUnknownClassPair pair, robin_hood::unordered_map<std::string, uint8_t>& names);
+    static void DefineFunctionLengthProperty(v8::Local<v8::Context> context, const TypeEncodingsList<ArrayCount>* encodings, v8::Local<v8::Function> func);
+
+    static void SwizzledInstanceMethodCallback(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info);
+    static void SwizzledPropertyCallback(v8::Local<v8::Name> property, const v8::PropertyDescriptor& desc, const v8::PropertyCallbackInfo<v8::Value>& info);
+
+    struct GlobalHandlerContext {
+        GlobalHandlerContext(bool isWorkerThread): isWorkerThread_(isWorkerThread) {
+        }
+        bool isWorkerThread_;
+    };
+
+    template<class T>
+    struct CacheItem {
+        CacheItem(const T* meta, const std::string className, void* userData = nullptr)
+        : meta_(meta),
+          className_(className),
+          userData_(userData) {
+            static_assert(std::is_base_of<Meta, T>::value, "Derived not derived from Meta");
+        }
+        const T* meta_;
+        const std::string className_;
+        void* userData_;
+    };
+};
+
+}
+
+#endif /* MetadataBuilder_h */

package/pods/Headers/runtime/MetadataInlines.h

@@ -0,0 +1,157 @@
+#ifndef MetadataInlines_h
+#define MetadataInlines_h
+
+#include <objc/runtime.h>
+#include "StringHasher.h"
+
+namespace tns {
+
+void LogMetadataUnavailable(const char* identifierString, uint8_t majorVersion, uint8_t minorVersion, const char* baseName);
+
+inline size_t compareIdentifiers(const char* nullTerminated, const char* notNullTerminated, size_t length) {
+    int result = strncmp(nullTerminated, notNullTerminated, length);
+    return (result == 0) ? strlen(nullTerminated) - length : result;
+}
+
+// GlobalTable
+
+template <GlobalTableType TYPE>
+const InterfaceMeta* GlobalTable<TYPE>::findInterfaceMeta(const char* identifierString) const {
+    unsigned hash = WTF::StringHasher::computeHashAndMaskTop8Bits<LChar>(reinterpret_cast<const LChar*>(identifierString));
+    return this->findInterfaceMeta(identifierString, strlen(identifierString), hash);
+}
+
+template <GlobalTableType TYPE>
+const InterfaceMeta* GlobalTable<TYPE>::findInterfaceMeta(const char* identifierString, size_t length, unsigned hash) const {
+    const Meta* meta = this->findMeta(identifierString, length, hash, /*onlyIfAvailable*/ false);
+    if (meta == nullptr) {
+        return nullptr;
+    }
+
+    // Meta should be an interface, but it could also be a protocol in case of a
+    // private interface having the same name as a public protocol
+    assert(meta->type() == MetaType::Interface || (meta->type() == MetaType::ProtocolType && objc_getClass(meta->name()) != nullptr && objc_getProtocol(meta->name()) != nullptr));
+
+    if (meta->type() != MetaType::Interface) {
+        return nullptr;
+    }
+
+    const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(meta);
+    if (interfaceMeta->isAvailable()) {
+        return interfaceMeta;
+    } else {
+        const char* baseName = interfaceMeta->baseName();
+
+        tns::LogMetadataUnavailable(
+            std::string(identifierString, length).c_str(),
+            getMajorVersion(interfaceMeta->introducedIn()),
+            getMinorVersion(interfaceMeta->introducedIn()),
+            baseName
+        );
+
+        return this->findInterfaceMeta(baseName);
+    }
+}
+
+template <GlobalTableType TYPE>
+const ProtocolMeta* GlobalTable<TYPE>::findProtocol(const char* identifierString) const {
+    unsigned hash = WTF::StringHasher::computeHashAndMaskTop8Bits<LChar>(reinterpret_cast<const LChar*>(identifierString));
+    return this->findProtocol(identifierString, strlen(identifierString), hash);
+}
+
+template <GlobalTableType TYPE>
+const ProtocolMeta* GlobalTable<TYPE>::findProtocol(const char* identifierString, size_t length, unsigned hash) const {
+    // Do not check for availability when returning a protocol. Apple regularly create new protocols and move
+    // existing interface members there (e.g. iOS 12.0 introduced the UIFocusItemScrollableContainer protocol
+    // in UIKit which contained members that have existed in UIScrollView since iOS 2.0)
+
+    auto meta = this->findMeta(identifierString, length, hash, /*onlyIfAvailable*/ false);
+    ASSERT(!meta || meta->type() == ProtocolType);
+    return static_cast<const ProtocolMeta*>(meta);
+}
+
+template <GlobalTableType TYPE>
+const Meta* GlobalTable<TYPE>::findMeta(const char* identifierString, bool onlyIfAvailable) const {
+    unsigned hash = WTF::StringHasher::computeHashAndMaskTop8Bits<LChar>(reinterpret_cast<const LChar*>(identifierString));
+    return this->findMeta(identifierString, strlen(identifierString), hash, onlyIfAvailable);
+}
+
+template <GlobalTableType TYPE>
+const Meta* GlobalTable<TYPE>::findMeta(const char* identifierString, size_t length, unsigned hash, bool onlyIfAvailable) const {
+    int bucketIndex = hash % buckets.count;
+    if (this->buckets[bucketIndex].isNull()) {
+        return nullptr;
+    }
+    const ArrayOfPtrTo<Meta>& bucketContent = buckets[bucketIndex].value();
+    for (ArrayOfPtrTo<Meta>::iterator it = bucketContent.begin(); it != bucketContent.end(); it++) {
+        const Meta* meta = (*it).valuePtr();
+        if (this->compareName(*meta, identifierString, length)) {
+            return onlyIfAvailable ? (meta->isAvailable() ? meta : nullptr) : meta;
+        }
+    }
+    return nullptr;
+}
+
+template <>
+inline bool GlobalTable<ByJsName>::compareName(const Meta& meta, const char* identifierString, size_t length) {
+    return compareIdentifiers(meta.jsName(), identifierString, length) == 0;
+}
+
+template <>
+inline bool GlobalTable<ByNativeName>::compareName(const Meta& meta, const char* identifierString, size_t length) {
+    return compareIdentifiers(meta.name(), identifierString, length) == 0 || (meta.hasDemangledName() && compareIdentifiers(meta.demangledName(), identifierString, length) == 0);
+}
+
+// GlobalTable::iterator
+
+template <GlobalTableType TYPE>
+const Meta* GlobalTable<TYPE>::iterator::getCurrent() {
+    return this->_globalTable->buckets[_topLevelIndex].value()[_bucketIndex].valuePtr();
+}
+
+template <GlobalTableType TYPE>
+typename GlobalTable<TYPE>::iterator& GlobalTable<TYPE>::iterator::operator++() {
+    this->_bucketIndex++;
+    this->findNext();
+    return *this;
+}
+
+template <GlobalTableType TYPE>
+const Meta* GlobalTable<TYPE>::iterator::operator*() {
+    return this->getCurrent();
+}
+
+template <GlobalTableType TYPE>
+bool GlobalTable<TYPE>::iterator::operator==(const iterator& other) const {
+    return _globalTable == other._globalTable && _topLevelIndex == other._topLevelIndex && _bucketIndex == other._bucketIndex;
+}
+
+template <GlobalTableType TYPE>
+bool GlobalTable<TYPE>::iterator::operator!=(const iterator& other) const {
+    return !(*this == other);
+}
+
+template <GlobalTableType TYPE>
+void GlobalTable<TYPE>::iterator::findNext() {
+    if (this->_topLevelIndex == this->_globalTable->buckets.count) {
+        return;
+    }
+
+    do {
+        if (!this->_globalTable->buckets[_topLevelIndex].isNull()) {
+            int bucketLength = this->_globalTable->buckets[_topLevelIndex].value().count;
+            while (this->_bucketIndex < bucketLength) {
+                if (this->getCurrent() != nullptr) {
+                    return;
+                }
+                this->_bucketIndex++;
+            }
+        }
+        this->_bucketIndex = 0;
+        this->_topLevelIndex++;
+    } while (this->_topLevelIndex < this->_globalTable->buckets.count);
+}
+
+} // namespace tns
+
+#endif /* MetadataInlines_h */

package/pods/Headers/runtime/ModuleInternal.h

@@ -0,0 +1,59 @@
+#ifndef ModuleInternal_h
+#define ModuleInternal_h
+
+#include "Common.h"
+#include "robin_hood.h"
+
+namespace tns {
+
+class ModuleInternal {
+public:
+    ModuleInternal(v8::Local<v8::Context> context);
+    bool RunModule(v8::Isolate* isolate, std::string path);
+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);
+
+    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_;
+    };
+};
+
+}
+
+#endif /* ModuleInternal_h */

package/pods/Headers/runtime/NSDataAdapter.h

@@ -0,0 +1,13 @@
+#ifndef NSDataAdapter_h
+#define NSDataAdapter_h
+
+#import <Foundation/NSData.h>
+#include "Common.h"
+
+@interface NSDataAdapter : NSMutableData
+
+- (instancetype)initWithJSObject:(v8::Local<v8::Object>)jsObject isolate:(v8::Isolate*)isolate;
+
+@end
+
+#endif /* NSDataAdapter_h */

package/pods/Headers/runtime/NativeScriptException.h

@@ -0,0 +1,27 @@
+#ifndef NativeScriptException_h
+#define NativeScriptException_h
+
+#include "Common.h"
+#include <string>
+
+namespace tns {
+
+class NativeScriptException {
+public:
+    NativeScriptException(const std::string& message);
+    NativeScriptException(v8::Isolate* isolate, v8::TryCatch& tc, const std::string& message);
+    void ReThrowToV8(v8::Isolate* isolate);
+    static void OnUncaughtError(v8::Local<v8::Message> message, v8::Local<v8::Value> error);
+private:
+    v8::Persistent<v8::Value>* javascriptException_;
+    std::string message_;
+    std::string stackTrace_;
+    std::string fullMessage_;
+    static std::string GetErrorStackTrace(v8::Isolate* isolate, const v8::Local<v8::StackTrace>& stackTrace);
+    static std::string GetErrorMessage(v8::Isolate* isolate, v8::Local<v8::Value>& error, const std::string& prependMessage = "");
+    static std::string GetFullMessage(v8::Isolate* isolate, const v8::TryCatch& tc, const std::string& jsExceptionMessage);
+};
+
+}
+
+#endif /* NativeScriptException_h */

package/pods/Headers/runtime/ObjectManager.h

@@ -0,0 +1,31 @@
+#ifndef ObjectManager_h
+#define ObjectManager_h
+
+#include "Common.h"
+
+namespace tns {
+
+class ObjectManager;
+
+struct ObjectWeakCallbackState {
+    ObjectWeakCallbackState(std::shared_ptr<v8::Persistent<v8::Value>> target) : target_(target) {
+    }
+
+    std::shared_ptr<v8::Persistent<v8::Value>> target_;
+};
+
+class ObjectManager {
+public:
+    static void Init(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
+    static std::shared_ptr<v8::Persistent<v8::Value>> Register(v8::Local<v8::Context> context, const v8::Local<v8::Value> obj);
+    static void FinalizerCallback(const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);
+private:
+    static bool DisposeValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
+    static void ReleaseNativeCounterpartCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static long GetRetainCount(id obj);
+    static bool IsInstanceOf(id obj, Class clazz);
+};
+
+}
+
+#endif /* ObjectManager_h */

package/pods/Headers/runtime/OneByteStringResource.h

@@ -0,0 +1,21 @@
+#ifndef OneByteStringResource_h
+#define OneByteStringResource_h
+
+#include "Common.h"
+
+namespace tns {
+
+class OneByteStringResource : public v8::String::ExternalOneByteStringResource {
+public:
+    OneByteStringResource(const char* data, size_t length);
+    ~OneByteStringResource() override;
+    const char* data() const override;
+    size_t length() const override;
+private:
+    const char* data_;
+    size_t length_;
+};
+
+}
+
+#endif /* OneByteStringResource_h */

package/pods/Headers/runtime/Pointer.h

@@ -0,0 +1,26 @@
+#ifndef Pointer_h
+#define Pointer_h
+
+#include "Common.h"
+#include "DataWrapper.h"
+
+namespace tns {
+
+class Pointer {
+public:
+    static void Register(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static v8::Local<v8::Value> NewInstance(v8::Local<v8::Context> context, void* handle);
+private:
+    static v8::Local<v8::Function> GetPointerCtorFunc(v8::Local<v8::Context> context);
+    static void PointerConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void RegisterAddMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+    static void RegisterSubtractMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+    static void RegisterToStringMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+    static void RegisterToHexStringMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+    static void RegisterToDecimalStringMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+    static void RegisterToNumberMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+};
+
+}
+
+#endif /* Pointer_h */

package/pods/Headers/runtime/PromiseProxy.h

@@ -0,0 +1,15 @@
+#ifndef PromiseProxy_h
+#define PromiseProxy_h
+
+#include "Common.h"
+
+namespace tns {
+
+class PromiseProxy {
+public:
+    static void Init(v8::Local<v8::Context> context);
+};
+
+}
+
+#endif /* PromiseProxy_h */

package/pods/Headers/runtime/Reference.h

@@ -0,0 +1,38 @@
+#ifndef Reference_h
+#define Reference_h
+
+#include "DataWrapper.h"
+#include "Common.h"
+
+namespace tns {
+
+class Reference {
+public:
+    static void Register(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static v8::Local<v8::Value> FromPointer(v8::Local<v8::Context> context, v8::Local<v8::Value> type, void* handle);
+    static v8::Local<v8::Function> GetInteropReferenceCtorFunc(v8::Local<v8::Context> context);
+    static void* GetWrappedPointer(v8::Local<v8::Context> context, v8::Local<v8::Value> reference, const TypeEncoding* typeEncoding);
+private:
+    struct DataPair {
+        DataPair(const TypeEncoding* typeEncoding, void* data, size_t size): typeEncoding_(typeEncoding), data_(data), size_(size) {
+        }
+
+        const TypeEncoding* typeEncoding_;
+        void* data_;
+        size_t size_;
+    };
+
+    static v8::Local<v8::Value> GetReferredValue(v8::Local<v8::Context> context, v8::Local<v8::Value> value);
+    static void ReferenceConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void IndexedPropertyGetCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info);
+    static void IndexedPropertySetCallback(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info);
+
+    static void GetValueCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info);
+    static void SetValueCallback(v8::Local<v8::Name> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info);
+    static void RegisterToStringMethod(v8::Local<v8::Context> context, v8::Local<v8::Object> prototype);
+    static DataPair GetTypeEncodingDataPair(v8::Local<v8::Object> obj);
+};
+
+}
+
+#endif /* Reference_h */

package/pods/Headers/runtime/Runtime.h

@@ -0,0 +1,67 @@
+#ifndef Runtime_h
+#define Runtime_h
+
+#include "libplatform/libplatform.h"
+#include "Common.h"
+#include "ModuleInternal.h"
+#include "MetadataBuilder.h"
+
+namespace tns {
+
+class Runtime {
+public:
+    Runtime();
+    ~Runtime();
+    v8::Isolate* CreateIsolate();
+    void Init(v8::Isolate* isolate);
+    void RunMainScript();
+    v8::Isolate* GetIsolate();
+
+    const int WorkerId();
+
+    void SetWorkerId(int workerId);
+
+    void RunModule(const std::string moduleName);
+
+    static void Initialize();
+
+    static Runtime* GetCurrentRuntime() {
+        return currentRuntime_;
+    }
+
+    static bool IsWorker() {
+        if (currentRuntime_ == nullptr) {
+            return false;
+        }
+
+        return currentRuntime_->WorkerId() > 0;
+    }
+
+    static std::shared_ptr<v8::Platform> GetPlatform() {
+        return platform_;
+    }
+
+    static id GetAppConfigValue(std::string key);
+
+    static bool IsAlive(v8::Isolate* isolate);
+private:
+    static thread_local Runtime* currentRuntime_;
+    static std::shared_ptr<v8::Platform> platform_;
+    static std::vector<v8::Isolate*> isolates_;
+    static bool mainThreadInitialized_;
+
+    void DefineGlobalObject(v8::Local<v8::Context> context);
+    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);
+    static void PerformanceNowCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    v8::Isolate* isolate_;
+    std::unique_ptr<ModuleInternal> moduleInternal_;
+    int workerId_;
+};
+
+}
+
+#endif /* Runtime_h */

package/pods/Headers/runtime/RuntimeConfig.h

@@ -0,0 +1,17 @@
+#ifndef RuntimeConfig_h
+#define RuntimeConfig_h
+
+#include <sys/types.h>
+#include <string>
+
+struct RuntimeConfig {
+    std::string BaseDir;
+    std::string ApplicationPath;
+    void* MetadataPtr;
+    bool IsDebug;
+    bool LogToSystemConsole;
+};
+
+extern struct RuntimeConfig RuntimeConfig;
+
+#endif /* RuntimeConfig_h */

package/pods/Headers/runtime/SetTimeout.h

@@ -0,0 +1,34 @@
+#ifndef SetTimeout_h
+#define SetTimeout_h
+
+#include "Common.h"
+#include "robin_hood.h"
+
+namespace tns {
+
+class SetTimeout {
+public:
+    static void Init(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate);
+private:
+    static void SetTimeoutCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void ClearTimeoutCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void Elapsed(const uint32_t key);
+    static void RemoveKey(const uint32_t key);
+    static uint32_t count_;
+
+    struct CacheEntry {
+        CacheEntry(v8::Isolate* isolate, v8::Persistent<v8::Function>* callback)
+            : isolate_(isolate),
+              callback_(callback) {
+        }
+
+        v8::Isolate* isolate_;
+        v8::Persistent<v8::Function>* callback_;
+    };
+
+    static robin_hood::unordered_map<uint32_t, CacheEntry> cache_;
+};
+
+}
+
+#endif /* SetTimeout_h */

package/pods/Headers/runtime/SimpleAllocator.h

@@ -0,0 +1,23 @@
+#ifndef SimpleAllocator_h
+#define SimpleAllocator_h
+
+#include "Common.h"
+
+namespace tns {
+
+class SimpleAllocator: public v8::ArrayBuffer::Allocator {
+public:
+    SimpleAllocator();
+
+    ~SimpleAllocator() override;
+
+    void* Allocate(size_t length) override;
+
+    void* AllocateUninitialized(size_t length) override;
+
+    void Free(void* data, size_t length) override;
+};
+
+}
+
+#endif /* SimpleAllocator_h */