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

package/pods/Headers/jsi/jsilib.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include "jsi/jsi.h"
+
+namespace facebook {
+namespace jsi {
+
+class FileBuffer : public Buffer {
+ public:
+  FileBuffer(const std::string& path);
+  ~FileBuffer() override;
+
+  size_t size() const override {
+    return size_;
+  }
+
+  const uint8_t* data() const override {
+    return data_;
+  }
+
+ private:
+  size_t size_;
+  uint8_t* data_;
+};
+
+// A trivial implementation of PreparedJavaScript that simply stores the source
+// buffer and URL.
+class SourceJavaScriptPreparation final : public jsi::PreparedJavaScript,
+                                          public jsi::Buffer {
+  std::shared_ptr<const jsi::Buffer> buf_;
+  std::string sourceURL_;
+
+ public:
+  SourceJavaScriptPreparation(
+      std::shared_ptr<const jsi::Buffer> buf,
+      std::string sourceURL)
+      : buf_(std::move(buf)), sourceURL_(std::move(sourceURL)) {}
+
+  const std::string& sourceURL() const {
+    return sourceURL_;
+  }
+
+  size_t size() const override {
+    return buf_->size();
+  }
+  const uint8_t* data() const override {
+    return buf_->data();
+  }
+};
+
+} // namespace jsi
+} // namespace facebook

package/pods/Headers/jsi/threadsafe.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <mutex>
+
+#include "jsi/decorator.h"
+#include "jsi/jsi.h"
+
+namespace facebook {
+namespace jsi {
+
+class ThreadSafeRuntime : public Runtime {
+ public:
+  virtual void lock() const = 0;
+  virtual void unlock() const = 0;
+  virtual Runtime& getUnsafeRuntime() = 0;
+};
+
+namespace detail {
+
+template <typename R, typename L>
+struct WithLock {
+  L lock;
+  WithLock(R& r) : lock(r) {}
+  void before() {
+    lock.lock();
+  }
+  void after() {
+    lock.unlock();
+  }
+};
+
+// The actual implementation of a given ThreadSafeRuntime. It's parameterized
+// by:
+//
+// - R: The actual Runtime type that this wraps
+// - L: A lock type that has three members:
+//   - L(R& r)       // ctor
+//   - void lock()
+//   - void unlock()
+template <typename R, typename L>
+class ThreadSafeRuntimeImpl final
+    : public WithRuntimeDecorator<WithLock<R, L>, R, ThreadSafeRuntime> {
+ public:
+  template <typename... Args>
+  ThreadSafeRuntimeImpl(Args&&... args)
+      : WithRuntimeDecorator<WithLock<R, L>, R, ThreadSafeRuntime>(
+            unsafe_,
+            lock_),
+        unsafe_(std::forward<Args>(args)...),
+        lock_(unsafe_) {}
+
+  R& getUnsafeRuntime() override {
+    return WithRuntimeDecorator<WithLock<R, L>, R, ThreadSafeRuntime>::plain();
+  }
+
+  void lock() const override {
+    lock_.before();
+  }
+
+  void unlock() const override {
+    lock_.after();
+  }
+
+ private:
+  R unsafe_;
+  mutable WithLock<R, L> lock_;
+};
+
+} // namespace detail
+
+} // namespace jsi
+} // namespace facebook

package/pods/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/pods/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/pods/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/pods/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/pods/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/pods/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/pods/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/pods/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/pods/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 */