@nativescript/canvas 2.0.0-alpha.3 → 2.0.0-alpha.31

package/src-native/ios/Headers/inspector/third_party/inspector_protocol/crdtp/status.h

@@ -0,0 +1,139 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_CRDTP_STATUS_H_
+#define V8_CRDTP_STATUS_H_
+
+#include <cassert>
+#include <cstddef>
+#include <limits>
+#include <string>
+
+#include "export.h"
+
+namespace v8_crdtp {
+// =============================================================================
+// Status and Error codes
+// =============================================================================
+
+enum class Error {
+  OK = 0,
+
+  // JSON parsing errors; checked when parsing / converting from JSON.
+  // See json.{h,cc}.
+  JSON_PARSER_UNPROCESSED_INPUT_REMAINS = 0x01,
+  JSON_PARSER_STACK_LIMIT_EXCEEDED = 0x02,
+  JSON_PARSER_NO_INPUT = 0x03,
+  JSON_PARSER_INVALID_TOKEN = 0x04,
+  JSON_PARSER_INVALID_NUMBER = 0x05,
+  JSON_PARSER_INVALID_STRING = 0x06,
+  JSON_PARSER_UNEXPECTED_ARRAY_END = 0x07,
+  JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED = 0x08,
+  JSON_PARSER_STRING_LITERAL_EXPECTED = 0x09,
+  JSON_PARSER_COLON_EXPECTED = 0x0a,
+  JSON_PARSER_UNEXPECTED_MAP_END = 0x0b,
+  JSON_PARSER_COMMA_OR_MAP_END_EXPECTED = 0x0c,
+  JSON_PARSER_VALUE_EXPECTED = 0x0d,
+
+  // CBOR parsing errors; checked when parsing / converting from CBOR.
+  CBOR_INVALID_INT32 = 0x0e,
+  CBOR_INVALID_DOUBLE = 0x0f,
+  CBOR_INVALID_ENVELOPE = 0x10,
+  CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH = 0x11,
+  CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE = 0x12,
+  CBOR_INVALID_STRING8 = 0x13,
+  CBOR_INVALID_STRING16 = 0x14,
+  CBOR_INVALID_BINARY = 0x15,
+  CBOR_UNSUPPORTED_VALUE = 0x16,
+  CBOR_NO_INPUT = 0x17,
+  CBOR_INVALID_START_BYTE = 0x18,
+  CBOR_UNEXPECTED_EOF_EXPECTED_VALUE = 0x19,
+  CBOR_UNEXPECTED_EOF_IN_ARRAY = 0x1a,
+  CBOR_UNEXPECTED_EOF_IN_MAP = 0x1b,
+  CBOR_INVALID_MAP_KEY = 0x1c,
+  CBOR_DUPLICATE_MAP_KEY = 0x1d,
+  CBOR_STACK_LIMIT_EXCEEDED = 0x1e,
+  CBOR_TRAILING_JUNK = 0x1f,
+  CBOR_MAP_START_EXPECTED = 0x20,
+  CBOR_MAP_STOP_EXPECTED = 0x21,
+  CBOR_ARRAY_START_EXPECTED = 0x22,
+  CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED = 0x23,
+
+  // Message errors are constraints we place on protocol messages coming
+  // from a protocol client; these are checked in crdtp::Dispatchable
+  // (see dispatch.h) as it performs a shallow parse.
+  MESSAGE_MUST_BE_AN_OBJECT = 0x24,
+  MESSAGE_MUST_HAVE_INTEGER_ID_PROPERTY = 0x25,
+  MESSAGE_MUST_HAVE_STRING_METHOD_PROPERTY = 0x26,
+  MESSAGE_MAY_HAVE_STRING_SESSION_ID_PROPERTY = 0x27,
+  MESSAGE_MAY_HAVE_OBJECT_PARAMS_PROPERTY = 0x28,
+  MESSAGE_HAS_UNKNOWN_PROPERTY = 0x29,
+
+  BINDINGS_MANDATORY_FIELD_MISSING = 0x30,
+  BINDINGS_BOOL_VALUE_EXPECTED = 0x31,
+  BINDINGS_INT32_VALUE_EXPECTED = 0x32,
+  BINDINGS_DOUBLE_VALUE_EXPECTED = 0x33,
+  BINDINGS_STRING_VALUE_EXPECTED = 0x34,
+  BINDINGS_STRING8_VALUE_EXPECTED = 0x35,
+  BINDINGS_BINARY_VALUE_EXPECTED = 0x36,
+  BINDINGS_DICTIONARY_VALUE_EXPECTED = 0x37,
+};
+
+// A status value with position that can be copied. The default status
+// is OK. Usually, error status values should come with a valid position.
+struct Status {
+  static constexpr size_t npos() { return std::numeric_limits<size_t>::max(); }
+
+  bool ok() const { return error == Error::OK; }
+
+  Error error = Error::OK;
+  size_t pos = npos();
+  Status(Error error, size_t pos) : error(error), pos(pos) {}
+  Status() = default;
+
+  bool IsMessageError() const {
+    return error >= Error::MESSAGE_MUST_BE_AN_OBJECT &&
+           error <= Error::MESSAGE_HAS_UNKNOWN_PROPERTY;
+  }
+
+  // Returns 7 bit US-ASCII string, either "OK" or an error message without
+  // position.
+  std::string Message() const;
+
+  // Returns a 7 bit US-ASCII string, either "OK" or an error message that
+  // includes the position.
+  std::string ToASCIIString() const;
+};
+
+template <typename T>
+class StatusOr {
+ public:
+  explicit StatusOr(const T& value) : value_(value) {}
+  explicit StatusOr(T&& value) : value_(std::move(value)) {}
+  explicit StatusOr(const Status& status) : status_(status) {}
+
+  bool ok() const { return status_.ok(); }
+  T& operator*() & {
+    assert(ok());
+    return value_;
+  }
+  const T& operator*() const& { return value(); }
+  T&& operator*() && { return value(); }
+  const Status& status() const { return status_; }
+
+  T& value() & { return *this; }
+  T&& value() && {
+    assert(ok());
+    return std::move(value_);
+  }
+  const T& value() const& { return *this; }
+
+ private:
+  Status status_;
+  T value_;
+};
+
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_STATUS_H_

package/src-native/ios/Headers/inspector/utils.h

@@ -0,0 +1,32 @@
+#ifndef utils_h
+#define utils_h
+
+#include "include/v8-inspector.h"
+
+namespace v8_inspector {
+
+std::string GetMIMEType(std::string filePath);
+std::string ToStdString(const v8_inspector::StringView& value);
+v8::Local<v8::Function> GetDebuggerFunction(v8::Local<v8::Context> context, std::string domain, std::string functionName, v8::Local<v8::Object>& domainDebugger);
+std::string GetDomainMethod(v8::Isolate* isolate, const v8::Local<v8::Object>& arg, std::string domain);
+
+class NetworkRequestData {
+public:
+    NetworkRequestData(std::u16string data, bool hasTextContent): data_(data), hasTextContent_(hasTextContent) {
+    }
+
+    const char16_t* GetData() {
+        return this->data_.data();
+    }
+
+    const bool HasTextContent() {
+        return this->hasTextContent_;
+    }
+private:
+    std::u16string data_;
+    bool hasTextContent_;
+};
+
+}
+
+#endif /* utils_h */

package/src-native/ios/Headers/inspector/v8-inspector-platform.h

@@ -0,0 +1,44 @@
+#ifndef v8_inspector_platform_h
+#define v8_inspector_platform_h
+
+using namespace std;
+using namespace v8;
+using namespace platform;
+
+#include "include/v8-platform.h"
+#include "src/base/platform/mutex.h"
+#include "src/libplatform/default-platform.h"
+
+#ifdef DEBUG
+[[noreturn]]
+void V8_Fatal(const char* file, int line, const char* format, ...) {
+    printf("FATAL ERROR");
+    throw;
+}
+#endif
+
+namespace v8_inspector {
+
+class V8InspectorPlatform: public DefaultPlatform {
+public:
+    explicit V8InspectorPlatform(int thread_pool_size = 0, v8::platform::IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled, unique_ptr<TracingController> tracing_controller = {}) {
+    }
+
+    void CallDelayedOnWorkerThread(unique_ptr<Task> task, double delay_in_seconds) override {
+        DefaultPlatform::CallDelayedOnWorkerThread(move(task), 0);
+    }
+
+    static std::unique_ptr<Platform> CreateDefaultPlatform() {
+        return NewDefaultPlatform();
+    }
+private:
+    static unique_ptr<Platform> NewDefaultPlatform() {
+        unique_ptr<DefaultPlatform> platform(new V8InspectorPlatform());
+        platform->EnsureBackgroundTaskRunnerInitialized();
+        return move(platform);
+    }
+};
+
+}
+
+#endif /* v8_inspector_platform_h */

package/src-native/ios/Headers/runtime/ArgConverter.h

@@ -0,0 +1,61 @@
+#ifndef ArgConverter_h
+#define ArgConverter_h
+
+#include <vector>
+#include "libffi.h"
+#include "Common.h"
+#include "Caches.h"
+#include "DataWrapper.h"
+
+namespace tns {
+
+class ArgConverter;
+
+struct MethodCallbackWrapper {
+public:
+    MethodCallbackWrapper(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Value>> callback, const uint8_t initialParamIndex, const uint8_t paramsCount, const TypeEncoding* typeEncoding)
+        : isolate_(isolate),
+          callback_(callback),
+          initialParamIndex_(initialParamIndex),
+          paramsCount_(paramsCount),
+          typeEncoding_(typeEncoding) {
+    }
+    v8::Isolate* isolate_;
+    std::shared_ptr<v8::Persistent<v8::Value>> callback_;
+    const uint8_t initialParamIndex_;
+    const uint8_t paramsCount_;
+    const TypeEncoding* typeEncoding_;
+};
+
+class ArgConverter {
+public:
+    static void Init(v8::Local<v8::Context> context, v8::GenericNamedPropertyGetterCallback structPropertyGetter, v8::GenericNamedPropertySetterCallback structPropertySetter);
+    static v8::Local<v8::Value> Invoke(v8::Local<v8::Context> context, Class klass, v8::Local<v8::Object> receiver, V8Args& args, const MethodMeta* meta, bool isMethodCallback);
+    static v8::Local<v8::Value> ConvertArgument(v8::Local<v8::Context> context, BaseDataWrapper* wrapper, bool skipGCRegistration = false, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
+    static v8::Local<v8::Value> CreateJsWrapper(v8::Local<v8::Context> context, BaseDataWrapper* wrapper, v8::Local<v8::Object> receiver, bool skipGCRegistration = false, const std::vector<std::string>& additionalProtocols = std::vector<std::string>());
+    static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyObject(v8::Local<v8::Context> context, bool skipGCRegistration = false);
+    static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyStruct(v8::Local<v8::Context> context);
+    static const Meta* FindMeta(Class klass, const TypeEncoding* typeEncoding = nullptr);
+    static const Meta* GetMeta(std::string name);
+    static const ProtocolMeta* FindProtocolMeta(Protocol* protocol);
+    static void MethodCallback(ffi_cif* cif, void* retValue, void** argValues, void* userData);
+    static void SetValue(v8::Local<v8::Context> context, void* retValue, v8::Local<v8::Value> value, const TypeEncoding* typeEncoding);
+    static void ConstructObject(v8::Local<v8::Context> context, const v8::FunctionCallbackInfo<v8::Value>& info, Class klass, const InterfaceMeta* interfaceMeta = nullptr);
+private:
+    static v8::Local<v8::Function> CreateEmptyInstanceFunction(v8::Local<v8::Context> context, v8::GenericNamedPropertyGetterCallback propertyGetter = nullptr, v8::GenericNamedPropertySetterCallback propertySetter = nullptr);
+    static std::shared_ptr<v8::Persistent<v8::Value>> CreateEmptyInstance(v8::Local<v8::Context> context, v8::Persistent<v8::Function>* ctorFunc, bool skipGCRegistration = false);
+    static void FindMethodOverloads(Class klass, std::string methodName, MemberType type, std::vector<const MethodMeta*>& overloads);
+    static const MethodMeta* FindInitializer(v8::Local<v8::Context> context, Class klass, const InterfaceMeta* interfaceMeta, const v8::FunctionCallbackInfo<v8::Value>& info, std::vector<v8::Local<v8::Value>>& args);
+    static bool CanInvoke(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, v8::Local<v8::Value> arg);
+    static bool CanInvoke(v8::Local<v8::Context> context, const MethodMeta* candidate, const v8::FunctionCallbackInfo<v8::Value>& info);
+    static std::vector<v8::Local<v8::Value>> GetInitializerArgs(v8::Local<v8::Object> obj, std::string& constructorTokens);
+    static void IndexedPropertyGetterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& args);
+    static void IndexedPropertySetterCallback(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& args);
+    static bool IsErrorOutParameter(const TypeEncoding* typeEncoding);
+    static std::vector<const MethodMeta*> GetInitializers(Caches* cache, Class klass, const InterfaceMeta* interfaceMeta);
+    static void MethodCallbackInternal(ffi_cif* cif, void* retValue, void** argValues, void* userData);
+};
+
+}
+
+#endif /* ArgConverter_h */

package/src-native/ios/Headers/runtime/ArrayAdapter.h

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

package/src-native/ios/Headers/runtime/Caches.h

@@ -0,0 +1,98 @@
+#ifndef Caches_h
+#define Caches_h
+
+#include <string>
+#include <vector>
+#include "ConcurrentMap.h"
+#include "robin_hood.h"
+#include "Common.h"
+#include "Metadata.h"
+
+namespace tns {
+
+struct StructInfo;
+
+struct pair_hash {
+    template <class T1, class T2>
+    std::size_t operator() (const std::pair<T1, T2> &pair) const {
+        return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
+    }
+};
+
+class Caches {
+public:
+    class WorkerState {
+    public:
+        WorkerState(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Value>> poWorker, void* userData)
+            : isolate_(isolate),
+              poWorker_(poWorker),
+              userData_(userData) {
+        }
+
+        v8::Isolate* GetIsolate() {
+            return this->isolate_;
+        }
+
+        std::shared_ptr<v8::Persistent<v8::Value>> GetWorker() {
+            return this->poWorker_;
+        }
+
+        void* UserData() {
+            return this->userData_;
+        }
+    private:
+        v8::Isolate* isolate_;
+        std::shared_ptr<v8::Persistent<v8::Value>> poWorker_;
+        void* userData_;
+    };
+
+    Caches(v8::Isolate* isolate);
+    ~Caches();
+
+    static std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Metadata;
+    static std::shared_ptr<ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>> Workers;
+
+    static std::shared_ptr<Caches> Get(v8::Isolate* isolate);
+    static void Remove(v8::Isolate* isolate);
+
+    void SetContext(v8::Local<v8::Context> context);
+    v8::Local<v8::Context> GetContext();
+
+    robin_hood::unordered_map<const Meta*, std::unique_ptr<v8::Persistent<v8::Value>>> Prototypes;
+    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Object>>> ClassPrototypes;
+    robin_hood::unordered_map<const BaseClassMeta*, std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>> CtorFuncTemplates;
+    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> CtorFuncs;
+    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> ProtocolCtorFuncs;
+    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> StructConstructorFunctions;
+    robin_hood::unordered_map<BinaryTypeEncodingType, std::unique_ptr<v8::Persistent<v8::Object>>> PrimitiveInteropTypes;
+    robin_hood::unordered_map<std::string, std::unique_ptr<v8::Persistent<v8::Function>>> CFunctions;
+
+    robin_hood::unordered_map<id, std::shared_ptr<v8::Persistent<v8::Value>>> Instances;
+    robin_hood::unordered_map<std::pair<void*, std::string>, std::shared_ptr<v8::Persistent<v8::Value>>, pair_hash> StructInstances;
+    robin_hood::unordered_map<const void*, std::shared_ptr<v8::Persistent<v8::Object>>> PointerInstances;
+
+    std::function<v8::Local<v8::FunctionTemplate>(v8::Local<v8::Context>, const BaseClassMeta*, KnownUnknownClassPair, const std::vector<std::string>&)> ObjectCtorInitializer;
+    std::function<v8::Local<v8::Function>(v8::Local<v8::Context>, StructInfo)> StructCtorInitializer;
+    robin_hood::unordered_map<std::string, double> Timers;
+    robin_hood::unordered_map<const InterfaceMeta*, std::vector<const MethodMeta*>> Initializers;
+
+    std::unique_ptr<v8::Persistent<v8::Function>> EmptyObjCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> EmptyStructCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> SliceFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> OriginalExtendsFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> WeakRefGetterFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> WeakRefClearFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> SmartJSONStringifyFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> InteropReferenceCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> PointerCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> FunctionReferenceCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+    std::unique_ptr<v8::Persistent<v8::Function>> UnmanagedTypeCtorFunc = std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
+private:
+    static std::shared_ptr<ConcurrentMap<v8::Isolate*, std::shared_ptr<Caches>>> perIsolateCaches_;
+    v8::Isolate* isolate_;
+    std::shared_ptr<v8::Persistent<v8::Context>> context_;
+};
+
+}
+
+#endif /* Caches_h */

package/src-native/ios/Headers/runtime/ClassBuilder.h

@@ -0,0 +1,61 @@
+#ifndef ClassBuilder_h
+#define ClassBuilder_h
+
+#include "Common.h"
+#include "Metadata.h"
+
+namespace tns {
+
+struct PropertyCallbackContext {
+public:
+    PropertyCallbackContext(v8::Isolate* isolate, std::shared_ptr<v8::Persistent<v8::Function>> callback, std::shared_ptr<v8::Persistent<v8::Object>> implementationObject, const PropertyMeta* meta)
+        : isolate_(isolate),
+          callback_(callback),
+          implementationObject_(implementationObject),
+          meta_(meta) {
+        }
+    v8::Isolate* isolate_;
+    std::shared_ptr<v8::Persistent<v8::Function>> callback_;
+    std::shared_ptr<v8::Persistent<v8::Object>> implementationObject_;
+    const PropertyMeta* meta_;
+};
+
+class ClassBuilder {
+public:
+    static v8::Local<v8::FunctionTemplate> GetExtendFunction(v8::Isolate* isolate, const InterfaceMeta* interfaceMeta);
+    static Class GetExtendedClass(std::string baseClassName, std::string staticClassName);
+
+    static void RegisterBaseTypeScriptExtendsFunction(v8::Local<v8::Context> context);
+    static void RegisterNativeTypeScriptExtendsFunction(v8::Local<v8::Context> context);
+    static std::string GetTypeEncoding(const TypeEncoding* typeEncoding, int argsCount);
+private:
+    static unsigned long long classNameCounter_;
+
+    static void ExtendCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void SuperAccessorGetterCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info);
+    static void ExtendedClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+    static void ExposeDynamicMethods(v8::Local<v8::Context> context, Class extendedClass, v8::Local<v8::Value> exposedMethods, v8::Local<v8::Value> exposedProtocols, v8::Local<v8::Object> implementationObject);
+    static void ExposeDynamicMembers(v8::Local<v8::Context> context, Class extendedClass, v8::Local<v8::Object> implementationObject, v8::Local<v8::Object> nativeSignature);
+    static void VisitMethods(Class extendedClass, std::string methodName, const BaseClassMeta* meta, std::vector<const MethodMeta*>& methodMetas, std::vector<const ProtocolMeta*> exposedProtocols);
+    static void VisitProperties(std::string propertyName, const BaseClassMeta* meta, std::vector<const PropertyMeta*>& propertyMetas, std::vector<const ProtocolMeta*> exposedProtocols);
+    static void ExposeProperties(v8::Isolate* isolate, Class extendedClass, std::vector<const PropertyMeta*> propertyMetas, v8::Local<v8::Object> implementationObject, v8::Local<v8::Value> getter, v8::Local<v8::Value> setter);
+    static std::string GetTypeEncoding(const TypeEncoding* typeEncoding);
+    static BinaryTypeEncodingType GetTypeEncodingType(v8::Isolate* isolate, v8::Local<v8::Value> value);
+    static IMP FindNotOverridenMethod(Class klass, SEL method);
+
+
+    struct CacheItem {
+    public:
+        CacheItem(const InterfaceMeta* meta, id data)
+            : meta_(meta),
+              data_(data) {
+        }
+        const InterfaceMeta* meta_;
+        id data_;
+    };
+};
+
+}
+
+#endif /* ClassBuilder_h */

package/src-native/ios/Headers/runtime/Common.h

@@ -0,0 +1,9 @@
+#ifndef Common_h
+#define Common_h
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "v8.h"
+#pragma clang diagnostic pop
+
+#endif /* Common_h */

package/src-native/ios/Headers/runtime/ConcurrentMap.h

@@ -0,0 +1,55 @@
+#ifndef ConcurrentMap_h
+#define ConcurrentMap_h
+
+#include <shared_mutex>
+#include "robin_hood.h"
+
+namespace tns {
+
+template<class TKey, class TValue>
+class ConcurrentMap {
+public:
+    void Insert(TKey& key, TValue value) {
+        std::lock_guard<std::mutex> writerLock(this->containerMutex_);
+        this->container_[key] = value;
+    }
+
+    TValue Get(TKey& key) {
+        bool found;
+        return this->Get(key, found);
+    }
+
+    TValue Get(TKey& key, bool& found) {
+//      std::shared_lock<std::shared_timed_mutex> readerLock(this->containerMutex_);
+        std::lock_guard<std::mutex> writerLock(this->containerMutex_);
+        auto it = this->container_.find(key);
+        found = it != this->container_.end();
+        if (found) {
+            return it->second;
+        }
+        return nullptr;
+    }
+
+    bool ContainsKey(TKey& key) {
+//        std::shared_lock<std::shared_timed_mutex> readerLock(this->containerMutex_);
+        std::lock_guard<std::mutex> writerLock(this->containerMutex_);
+        auto it = this->container_.find(key);
+        return it != this->container_.end();
+    }
+
+    void Remove(TKey& key) {
+        std::lock_guard<std::mutex> writerLock(this->containerMutex_);
+        this->container_.erase(key);
+    }
+
+    ConcurrentMap() = default;
+    ConcurrentMap(const ConcurrentMap&) = delete;
+    ConcurrentMap& operator=(const ConcurrentMap&) = delete;
+private:
+    std::mutex containerMutex_;
+    robin_hood::unordered_map<TKey, TValue> container_;
+};
+
+}
+
+#endif /* ConcurrentMap_h */

package/src-native/ios/Headers/runtime/ConcurrentQueue.h

@@ -0,0 +1,28 @@
+#ifndef ConcurrentQueue_h
+#define ConcurrentQueue_h
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <vector>
+#include <string>
+#include <queue>
+#include <mutex>
+
+namespace tns {
+
+struct ConcurrentQueue {
+public:
+    void Initialize(CFRunLoopRef runLoop, void (*performWork)(void*), void* info);
+    void Push(std::string message);
+    std::vector<std::string> PopAll();
+    void Terminate();
+private:
+    std::queue<std::string> messagesQueue_;
+    CFRunLoopSourceRef runLoopTasksSource_ = nullptr;
+    CFRunLoopRef runLoop_ = nullptr;
+    std::mutex mutex_;
+    void SignalAndWakeUp();
+};
+
+}
+
+#endif /* ConcurrentQueue_h */

package/src-native/ios/Headers/runtime/Console.h

@@ -0,0 +1,27 @@
+#ifndef Console_h
+#define Console_h
+
+#include "Common.h"
+#include <string>
+
+namespace tns {
+
+class Console {
+public:
+    static void Init(v8::Local<v8::Context> context);
+private:
+    static void AttachLogFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> console, const std::string name, v8::FunctionCallback callback = Console::LogCallback);
+    static void LogCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void AssertCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void DirCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void TimeCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static void TimeEndCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+    static std::string BuildStringFromArgs(const v8::FunctionCallbackInfo<v8::Value>& args, int startingIndex = 0);
+    static const v8::Local<v8::String> BuildStringFromArg(v8::Local<v8::Context> context, const v8::Local<v8::Value>& val);
+    static const v8::Local<v8::String> TransformJSObject(v8::Local<v8::Object> object);
+    static const std::string VerbosityToInspectorVerbosity(const std::string level);
+};
+
+}
+
+#endif /* Console_h */

package/src-native/ios/Headers/runtime/Constants.h

@@ -0,0 +1,15 @@
+#ifndef Constants_h
+#define Constants_h
+
+#include <string>
+
+namespace tns {
+
+class Constants {
+public:
+    static const std::string SwizzledPrefix;
+};
+
+}
+
+#endif /* Constants_h */