@triniwiz/nativescript-masonkit 1.0.0-alpha.1 → 1.0.0-alpha.10

package/platforms/ios/Podfile

@@ -1 +1 @@
-pod 'NativeScript', path: "../../node_modules/@triniwiz/nativescript-masonkit/pods/NativeScript.podspec"
+pod 'NativeScript', path: "../../node_modules/@triniwiz/nativescript-masonkit/src-native/pods/NativeScript.podspec"

package/platforms/ios/build.xcconfig

@@ -1,2 +1,5 @@
-OTHER_LDFLAGS[sdk=*] = $(inherited) -framework Mason
+OTHER_LDFLAGS[sdk=*] = $(inherited) -framework Mason -framework Foundation
 
+HEADER_SEARCH_PATHS = $(inherited) "$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/NativeScript.framework/Headers" "$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/NativeScript.framework/Headers/include"
+
+CLANG_CXX_LANGUAGE_STANDARD = c++17

package/platforms/ios/prebuild.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+set -e
+
+source $HOME/.cargo/env
+source $HOME/.profile
+
+whereis cc
+
+function to_bool() {
+  local arg="$1"
+  case "$(echo "$arg" | tr '[:upper:]' '[:lower:]')" in
+  [0-9]+)
+    if [ $arg -eq 0 ]; then
+      echo false
+    else
+      echo true
+    fi
+    ;;
+  n | no | f | false) echo false ;;
+  y | yes | t | true) echo true ;;
+  *)
+    if [ -n "$arg" ]; then
+      echo "warning: invalid boolean argument ('$arg'). Expected true or false" >&2
+    fi
+    echo false
+    ;;
+  esac
+}
+
+CWD="$SRCROOT/../../../../crates"
+pushd "$SRCROOT/../../../.."
+
+IS_SIMULATOR=false
+
+IS_RELEASE=false
+RUST_BUILD_TYPE=""
+RUST_BUILD_TARGET=""
+
+if [[ $CONFIGURATION == Release ]]; then
+  IS_RELEASE=true
+fi
+
+
+
+if $IS_RELEASE; then
+  RUST_BUILD_TYPE="--release"
+fi
+
+
+
+PLATFORM_NAME="${PLATFORM_NAME:-iphoneos}"
+CURRENT_ARCH="${CURRENT_ARCH}"
+
+if [ -z "$CURRENT_ARCH" ] || [ "$CURRENT_ARCH" == "undefined_arch" ]; then
+    # Xcode 10 beta sets CURRENT_ARCH to "undefined_arch", this leads to incorrect linker arg.
+    # it's better to rely on platform name as fallback because architecture differs between simulator and device
+
+    if [[ "$PLATFORM_NAME" == *"simulator"* ]]; then
+        CURRENT_ARCH="arm64"
+        IS_SIMULATOR=true
+    else
+        CURRENT_ARCH="arm64"
+    fi
+fi
+
+
+if [[ $CURRENT_ARCH == x86_64 ]]; then
+  RUST_BUILD_TARGET="x86_64-apple-ios"
+fi
+
+
+if [[ $CURRENT_ARCH == arm64 ]]; then
+  if [[ $IS_SIMULATOR == false ]]; then
+    RUST_BUILD_TARGET="aarch64-apple-ios"
+  else
+    RUST_BUILD_TARGET="aarch64-apple-ios-sim"
+  fi
+fi
+
+
+export RUST_SRC_PATH="$(rustc --print sysroot)/lib/rustlib/src/rust/src"
+export DYLD_LIBRARY_PATH="$(rustc --print sysroot)/lib:$DYLD_LIBRARY_PATH:$DYLD_FALLBACK_LIBRARY_PATH"
+export RUST_BUILD_TARGET="$RUST_BUILD_TARGET"
+
+cbindgen --config "$CWD/mason-c/cbindgen.toml"  "$CWD/mason-c/src/lib.rs" -l c >"$SRCROOT/Mason/include/mason_native.h"
+cbindgen --config "$CWD/mason-ios/cbindgen.toml"  "$CWD/mason-ios/src/lib.rs" -l c >"$SRCROOT/Mason/include/mason_ios.h"
+
+
+if $IS_RELEASE; then
+  export RUSTFLAGS="-Zlocation-detail=none -C panic=abort -Zfmt-debug=none"
+  cargo +nightly build -Z build-std='std,panic_abort' -Z build-std-features='panic_immediate_abort,optimize_for_size'  --manifest-path Cargo.toml --target $RUST_BUILD_TARGET $RUST_BUILD_TYPE -p mason-ios
+
+else 
+  cargo build --manifest-path Cargo.toml --target $RUST_BUILD_TARGET $RUST_BUILD_TYPE -p mason-ios
+fi
+
+
+#cargo build --target aarch64-apple-ios -p canvas-ios
+
+# cargo +nightly build -Z build-std='std'  --manifest-path Cargo.toml --target $RUST_BUILD_TARGET $RUST_BUILD_TYPE -p canvas-ios
+popd

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();
+    }
+}