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

package/platforms/ios/src/module.modulemap

@@ -1,4 +1,4 @@
-module JSIModule {
-    header "JSIModule.h"
+module MasonV8Module {
+    header "MasonV8Module.h"
     export *
 }

package/platforms/new_native_src/cpp/Caches.cpp

@@ -0,0 +1,36 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#include "Caches.h"
+
+std::shared_ptr <ConcurrentMap<v8::Isolate *, std::shared_ptr < Caches>>>
+Caches::perIsolateCaches_ =
+std::make_shared < ConcurrentMap<v8::Isolate *, std::shared_ptr < Caches>>
+>();
+
+Caches::Caches(v8::Isolate *isolate) : isolate_(isolate) {}
+
+Caches::~Caches() {}
+
+std::shared_ptr <Caches> Caches::Get(v8::Isolate *isolate) {
+    std::shared_ptr <Caches> cache = Caches::perIsolateCaches_->Get(isolate);
+    if (cache == nullptr) {
+        cache = std::make_shared<Caches>(isolate);
+        Caches::perIsolateCaches_->Insert(isolate, cache);
+    }
+
+    return cache;
+}
+
+void Caches::Remove(v8::Isolate *isolate) {
+    Caches::perIsolateCaches_->Remove(isolate);
+}
+
+void Caches::SetContext(v8::Local<v8::Context> context) {
+    this->context_ = std::make_shared<v8::Persistent<v8::Context >>(this->isolate_, context);
+}
+
+v8::Local<v8::Context> Caches::GetContext() {
+    return this->context_->Get(this->isolate_);
+}

package/platforms/new_native_src/cpp/Caches.h

@@ -0,0 +1,42 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#ifndef MASON_CACHES_H
+#define MASON_CACHES_H
+
+#include "Common.h"
+#include "ConcurrentMap.h"
+
+class Caches {
+public:
+    Caches(v8::Isolate *isolate);
+
+    ~Caches();
+
+    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();
+
+
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> MasonTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+            nullptr);
+
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> MasonNodeTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+            nullptr);
+
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> MasonStyleTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+            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 //MASON_CACHES_H

package/platforms/new_native_src/cpp/Common.h

@@ -0,0 +1,34 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+#pragma once
+
+#ifndef MASON_COMMON_H
+#define MASON_COMMON_H
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#include "include/mason_native.h"
+#include "include/v8.h"
+#endif
+
+#ifdef __APPLE__
+#include <NativeScript/include/v8.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "include/mason_native.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+#endif //MASON_COMMON_H

package/platforms/new_native_src/cpp/ConcurrentMap.h

@@ -0,0 +1,57 @@
+//
+// Created by Osei Fortune on 06/07/2023.
+//
+
+#ifndef MASON_CONCURRENTMAP_H
+#define MASON_CONCURRENTMAP_H
+
+#include <shared_mutex>
+#include "include/robin_hood.h"
+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 //MASON_CONCURRENTMAP_H

package/platforms/new_native_src/cpp/Helpers.cpp

@@ -0,0 +1,101 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#include "Helpers.h"
+
+
+const char *Helpers::LOG_TAG = "JS";
+int Helpers::m_maxLogcatObjectSize = 4096;
+
+
+
+#ifdef __ANDROID__
+
+void Helpers::sendToADBLogcat(const std::string &message, android_LogPriority logPriority) {
+    // limit the size of the message that we send to logcat using the predefined value in package.json
+    auto messageToLog = message;
+    if (messageToLog.length() > m_maxLogcatObjectSize) {
+        messageToLog = messageToLog.erase(m_maxLogcatObjectSize, std::string::npos);
+        messageToLog = messageToLog + "...";
+    }
+
+    // split strings into chunks of 4000 characters
+    // __android_log_write can't send more than 4000 to the stdout at a time
+    auto messageLength = messageToLog.length();
+    int maxStringLength = 4000;
+
+    if (messageLength < maxStringLength) {
+        __android_log_write(logPriority, Helpers::LOG_TAG, messageToLog.c_str());
+    } else {
+        for (int i = 0; i < messageLength; i += maxStringLength) {
+            auto messagePart = messageToLog.substr(i, maxStringLength);
+
+            __android_log_write(logPriority, Helpers::LOG_TAG, messagePart.c_str());
+        }
+    }
+}
+
+#endif
+
+
+void Helpers::LogToConsole(const std::string &message) {
+#ifdef __ANDROID__
+    sendToADBLogcat(message, android_LogPriority::ANDROID_LOG_INFO);
+#endif
+
+#ifdef __APPLE__
+#endif
+}
+
+void Helpers::ThrowIllegalConstructor(v8::Isolate *isolate) {
+    auto msg = ConvertToV8String(isolate, "Illegal constructor");
+    auto err = v8::Exception::TypeError(msg);
+    isolate->ThrowException(err);
+}
+
+v8::Local<v8::String> Helpers::ConvertToV8String(v8::Isolate *isolate, const std::string &string) {
+    return v8::String::NewFromUtf8(isolate, string.c_str()).ToLocalChecked();
+}
+
+std::string Helpers::ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
+    if (value.IsEmpty()) {
+        return {};
+    }
+
+    if (value->IsStringObject()) {
+        v8::Local<v8::String> obj = value.As<v8::StringObject>()->ValueOf();
+        return ConvertFromV8String(isolate, obj);
+    }
+
+    v8::String::Utf8Value result(isolate, value);
+
+    const char *val = *result;
+
+    if (val == nullptr) {
+        return {};
+    }
+
+    return {*result};
+}
+
+
+void
+Helpers::SetPrivate(v8::Isolate *isolate, v8::Local<v8::Object> object, const std::string &property,
+                    v8::Local<v8::Value> value) {
+    auto context = isolate->GetCurrentContext();
+    auto key = v8::Private::ForApi(isolate, Helpers::ConvertToV8String(isolate, property));
+    object->SetPrivate(context, key, value);
+}
+
+v8::Local<v8::Value> Helpers::GetPrivate(v8::Isolate *isolate, v8::Local<v8::Object> object,
+                                         const std::string &property) {
+    auto context = isolate->GetCurrentContext();
+    auto key = v8::Private::ForApi(isolate, Helpers::ConvertToV8String(isolate, property));
+    auto value = object->GetPrivate(context, key);
+    if (value.IsEmpty()) {
+        return v8::Undefined(isolate);
+    } else {
+        return value.ToLocalChecked();
+    }
+}

package/platforms/new_native_src/cpp/Helpers.h

@@ -0,0 +1,364 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+#pragma once
+#ifndef MASON_HELPERS_H
+#define MASON_HELPERS_H
+
+#include "Common.h"
+
+
+class Helpers {
+public:
+
+    static const char *LOG_TAG;
+
+    static int m_maxLogcatObjectSize;
+
+#ifdef __ANDROID__
+
+    static void sendToADBLogcat(const std::string &message, android_LogPriority logPriority);
+
+#endif
+
+    static void LogToConsole(const std::string &message);
+
+    static void ThrowIllegalConstructor(v8::Isolate *isolate);
+
+    static v8::Local<v8::String> ConvertToV8String(v8::Isolate *isolate, const std::string &string);
+
+    static std::string ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value);
+
+    static void
+    SetPrivate(v8::Isolate *isolate, v8::Local<v8::Object> object, const std::string &property,
+               v8::Local<v8::Value> value);
+
+    static v8::Local<v8::Value>
+    GetPrivate(v8::Isolate *isolate, v8::Local<v8::Object> object, const std::string &property);
+};
+
+inline static v8::Local<v8::Value>
+gridPlacementToJS(v8::Isolate *isolate, CMasonGridPlacement placement) {
+    switch (placement.value_type) {
+        case CMasonGridPlacementType::MasonGridPlacementTypeAuto: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, placement.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "type"),
+                        v8::Number::New(isolate, 0))
+                    .Check();
+            return object;
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeLine: {
+
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, placement.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "type"),
+                        v8::Number::New(isolate, 1))
+                    .Check();
+            return object;
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeSpan: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, placement.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "type"),
+                        v8::Number::New(isolate, 2))
+                    .Check();
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonGridPlacement jsToGridPlacement(short value, int value_type) {
+    switch ((CMasonGridPlacementType) value_type) {
+        case CMasonGridPlacementType::MasonGridPlacementTypeAuto: {
+            return CMasonGridPlacement{0, CMasonGridPlacementType::MasonGridPlacementTypeAuto};
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeLine: {
+            return CMasonGridPlacement{value, CMasonGridPlacementType::MasonGridPlacementTypeLine};
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeSpan: {
+            return CMasonGridPlacement{value, CMasonGridPlacementType::MasonGridPlacementTypeSpan};
+        }
+        default:
+            // assert ??
+            return CMasonGridPlacement{0, CMasonGridPlacementType::MasonGridPlacementTypeAuto};
+    }
+}
+
+inline static v8::Local<v8::Value>
+lengthPercentageToJS(v8::Isolate *isolate, CMasonLengthPercentage length) {
+    switch (length.value_type) {
+        case CMasonLengthPercentageType::MasonLengthPercentagePercent: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value / 100))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "%"))
+                    .Check();
+            return object;
+        }
+        case CMasonLengthPercentageType::MasonLengthPercentagePoints: {
+
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "px"))
+                    .Check();
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonLengthPercentage jsToLengthPercentage(float value, int value_type) {
+    switch ((CMasonLengthPercentageType) value_type) {
+        case CMasonLengthPercentageType::MasonLengthPercentagePercent: {
+            return CMasonLengthPercentage{value,
+                                          CMasonLengthPercentageType::MasonLengthPercentagePercent};
+        }
+        case CMasonLengthPercentageType::MasonLengthPercentagePoints: {
+            return CMasonLengthPercentage{value,
+                                          CMasonLengthPercentageType::MasonLengthPercentagePoints};
+        }
+        default:
+            // assert ??
+            return CMasonLengthPercentage{0,
+                                          CMasonLengthPercentageType::MasonLengthPercentagePoints};
+    }
+}
+
+inline static CMasonLengthPercentageType jsToLengthPercentageType(int value_type) {
+    switch ((CMasonLengthPercentageType) value_type) {
+        case CMasonLengthPercentageType::MasonLengthPercentagePercent: {
+            return CMasonLengthPercentageType::MasonLengthPercentagePercent;
+        }
+        case CMasonLengthPercentageType::MasonLengthPercentagePoints: {
+            return CMasonLengthPercentageType::MasonLengthPercentagePoints;
+        }
+        default:
+            // assert invalid type ???
+            return CMasonLengthPercentageType::MasonLengthPercentagePoints;
+    }
+}
+
+inline static v8::Local<v8::Value>
+lengthPercentageAutoToJS(v8::Isolate *isolate, CMasonLengthPercentageAuto length) {
+    switch (length.value_type) {
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoAuto:
+            return Helpers::ConvertToV8String(isolate, "auto");
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPercent: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value / 100))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "%"))
+                    .Check();
+            return object;
+        }
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "px"))
+                    .Check();
+
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonLengthPercentageAuto jsToLengthPercentageAuto(float value, int value_type) {
+    switch ((CMasonLengthPercentageAutoType) value_type) {
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoAuto:
+            return CMasonLengthPercentageAuto{value,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoAuto};
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPercent: {
+            return CMasonLengthPercentageAuto{value,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPercent};
+        }
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints: {
+            return CMasonLengthPercentageAuto{value,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints};
+        }
+        default:
+            // assert invalid type ???
+            return CMasonLengthPercentageAuto{0,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints};
+    }
+}
+
+inline static CMasonLengthPercentageAutoType jsToLengthPercentageAutoType(int value_type) {
+    return (CMasonLengthPercentageAutoType) value_type;
+}
+
+inline static v8::Local<v8::Value> dimensionToJS(v8::Isolate *isolate, CMasonDimension dimension) {
+    switch ((CMasonDimensionType) dimension.value_type) {
+        case CMasonDimensionType::MasonDimensionAuto:
+            return Helpers::ConvertToV8String(isolate, "auto");
+        case CMasonDimensionType::MasonDimensionPercent: {
+
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, dimension.value / 100))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "%"))
+                    .Check();
+            return object;
+        }
+        case CMasonDimensionType::MasonDimensionPoints: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, dimension.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "px"))
+                    .Check();
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonDimension jsToDimension(float value, int value_type) {
+    switch ((CMasonDimensionType) value_type) {
+        case CMasonDimensionType::MasonDimensionAuto:
+            return CMasonDimension{value, CMasonDimensionType::MasonDimensionAuto};
+        case CMasonDimensionType::MasonDimensionPercent: {
+            return CMasonDimension{value, CMasonDimensionType::MasonDimensionPercent};
+        }
+        case CMasonDimensionType::MasonDimensionPoints: {
+            return CMasonDimension{value, CMasonDimensionType::MasonDimensionPoints};
+        }
+        default:
+            // assert invalid type ???
+            return CMasonDimension{0, CMasonDimensionType::MasonDimensionPoints};
+    }
+}
+
+inline static CMasonDimensionType jsToDimensionType(int value_type) {
+    return (CMasonDimensionType) value_type;
+}
+
+/*
+inline static v8::Local<v8::Value> sizeToJS(v8::Isolate *isolate, CMasonDimensionSize size)
+{
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"width"),
+                dimensionToJS(isolate, size.width))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"height"),
+                dimensionToJS(isolate, size.width))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+sizeToJS(v8::Isolate *isolate, CMasonLengthPercentageSize size)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"width"),
+                lengthPercentageToJS(isolate, size.width))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"height"),
+                lengthPercentageToJS(isolate, size.width))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+sizeToJS(v8::Isolate *isolate, CMasonLengthPercentageAutoSize size)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"width"),
+                lengthPercentageAutoToJS(isolate, size.width))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"height"),
+                lengthPercentageAutoToJS(isolate, size.width))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object> rectToJS(v8::Isolate *isolate, CMasonDimensionRect rect)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"left"),
+                dimensionToJS(isolate, rect.left))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"right"),
+                dimensionToJS(isolate, rect.right))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"top"),
+                dimensionToJS(isolate, rect.top))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"bottom"),
+                dimensionToJS(isolate, rect.bottom))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+rectToJS(v8::Isolate *isolate, CMasonLengthPercentageRect rect)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"left"),
+                lengthPercentageToJS(isolate, rect.left))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"right"),
+                lengthPercentageToJS(isolate, rect.right))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"top"),
+                lengthPercentageToJS(isolate, rect.top))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"bottom"),
+                lengthPercentageToJS(isolate, rect.bottom))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+rectToJS(v8::Isolate *isolate, CMasonLengthPercentageAutoRect rect)
+{
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"left"),
+                lengthPercentageAutoToJS(isolate, rect.left))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"right"),
+                lengthPercentageAutoToJS(isolate, rect.right))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"top"),
+                lengthPercentageAutoToJS(isolate, rect.top))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"bottom"),
+                lengthPercentageAutoToJS(isolate, rect.bottom))
+            .Check();
+    return object;
+}
+
+*/
+
+
+
+#endif //MASON_HELPERS_H