@triniwiz/nativescript-masonkit 1.0.0-alpha.8 → 1.0.0-beta.0

package/src-native/pods/Headers/jsi/jsilib.h

@@ -1,59 +0,0 @@
-/*
- * 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/src-native/pods/Headers/jsi/threadsafe.h

@@ -1,79 +0,0 @@
-/*
- * 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/src-native/pods/Headers/runtime/ArgConverter.h

@@ -1,61 +0,0 @@
-#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/pods/Headers/runtime/ArrayAdapter.h

@@ -1,13 +0,0 @@
-#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/pods/Headers/runtime/Caches.h

@@ -1,98 +0,0 @@
-#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/pods/Headers/runtime/ClassBuilder.h

@@ -1,61 +0,0 @@
-#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/pods/Headers/runtime/Common.h

@@ -1,9 +0,0 @@
-#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/pods/Headers/runtime/ConcurrentMap.h

@@ -1,55 +0,0 @@
-#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/pods/Headers/runtime/ConcurrentQueue.h

@@ -1,28 +0,0 @@
-#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/pods/Headers/runtime/Console.h

@@ -1,27 +0,0 @@
-#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/pods/Headers/runtime/Constants.h

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