@nativescript/canvas 2.0.0-alpha.5 → 2.0.0-alpha.50

package/platforms/ios/src/cpp/CanvasJSIModule.h

@@ -6,10 +6,7 @@
 
 #include <memory>
 #include <array>
-#include "NativeScript/JSIRuntime.h"
 #include "canvas2d/CanvasRenderingContext2DImpl.h"
-
-#import "canvas-cxx/src/lib.rs.h"
 #include "Helpers.h"
 
 #include "ImageAssetImpl.h"
@@ -22,39 +19,24 @@
 #include "webgl/WebGLRenderingContext.h"
 #include "webgl2/WebGL2RenderingContext.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-template<typename NativeFunc>
-static void
-createGlobalFunc(jsi::Runtime &jsiRuntime, const char *prop, int paramCount, NativeFunc &&func) {
-    auto f = jsi::Function::createFromHostFunction(jsiRuntime,
-                                                   jsi::PropNameID::forAscii(jsiRuntime, prop),
-                                                   paramCount,
-                                                   std::forward<NativeFunc>(func));
-    jsiRuntime.global().setProperty(jsiRuntime, prop, std::move(f));
-}
-
-#define CREATE_GLOBAL_FUNC(prop, paramCount, func) \
-    createFunc(jsiRuntime, prop, paramCount, func)
-
-
-template<typename NativeFunc>
-static void
-createFunc(jsi::Runtime &jsiRuntime, jsi::Object &object, const char *prop, int paramCount,
-           NativeFunc &&func) {
-    auto f = jsi::Function::createFromHostFunction(jsiRuntime,
-                                                   jsi::PropNameID::forAscii(jsiRuntime, prop),
-                                                   paramCount,
-                                                   std::forward<NativeFunc>(func));
-    object.setProperty(jsiRuntime, prop, std::move(f));
-}
-
-#define CREATE_FUNC(prop, object, paramCount, func) \
-    createFunc(jsiRuntime, object, prop, paramCount, func)
+#include "URLImpl.h"
 
 class CanvasJSIModule {
 public:
-    static void install(facebook::jsi::Runtime &rt);
+    static void install(v8::Isolate *isolate);
+
+    static void CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Create2DContext(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Create2DContextWithPointer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void AddFontFamily(const v8::FunctionCallbackInfo<v8::Value> &args);
 };
 

package/platforms/ios/src/cpp/Common.h

@@ -0,0 +1,30 @@
+//
+// Created by Osei Fortune on 10/06/2022.
+//
+
+#pragma once
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __APPLE__
+#include <NativeScript/include/v8.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <CanvasNative/canvas_ios.h>
+#include <CanvasNative/canvas_native.h>
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#ifdef __ANDROID__
+#include "include/v8.h"
+#include "include/canvas_android.h"
+#include <android/log.h>
+#include <thread>
+#endif
+

package/platforms/ios/src/cpp/ConcurrentMap.h

@@ -0,0 +1,54 @@
+//
+// Created by Osei Fortune on 10/06/2022.
+//
+
+#pragma once
+
+#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_;
+};

package/platforms/ios/src/cpp/Helpers.h

@@ -5,59 +5,357 @@
 #pragma once
 
 #include <memory>
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Common.h"
+#include "OneByteStringResource.h"
+#include "PerIsolateData.h"
+#include "v8-fast-api-calls.h"
+//#ifdef __APPLE__
+//#ifdef __OBJC__
+//#include <Foundation/Foundation.h>
+//#else
+//#include <CoreFoundation/CoreFoundation.h>
+//extern "C" void NSLog(CFStringRef format, ...);
+//#endif
+//#endif
 
-using namespace facebook;
 
-inline static int64_t getPointerValue(jsi::Runtime &runtime, const facebook::jsi::Value &value) {
-    return value.asBigInt(runtime).Int64Value(runtime);
+
+static const char *LOG_TAG = "JS";
+static int m_maxLogcatObjectSize = 4096;
+
+#ifdef __ANDROID__
+
+static void 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, LOG_TAG, messageToLog.c_str());
+    } else {
+        for (int i = 0; i < messageLength; i += maxStringLength) {
+            auto messagePart = messageToLog.substr(i, maxStringLength);
+
+            __android_log_write(logPriority, LOG_TAG, messagePart.c_str());
+        }
+    }
 }
 
-template<typename T>
-inline static rust::Slice<T>
-GetArrayBufferData(jsi::Runtime &runtime, facebook::jsi::ArrayBuffer &array) {
-    auto buf = array.data(runtime);
-    auto size = array.size(runtime);
+#endif
 
-    rust::Slice<T> slice(reinterpret_cast<T *>(buf), size);
-    return std::move(slice);
+//#ifdef __APPLE__
+//#ifndef __OBJC__
+//#define Log(fmt, ...) NSLog(CFSTR(fmt), ##__VA_ARGS__)
+//#else
+//#define Log(...) NSLog(__VA_ARGS__)
+//#endif
+//#endif
+
+
+
+static void LogToConsole(const std::string &message) {
+#ifdef __ANDROID__
+    sendToADBLogcat(message, android_LogPriority::ANDROID_LOG_INFO);
+#endif
+
+#ifdef __APPLE__
+    // Log("%s", message.c_str());
+#endif
 }
 
-template<typename T>
-inline static rust::Slice<T>
-GetTypedArrayData(jsi::Runtime &runtime, facebook::jsi::TypedArray &array) {
-    auto buf = array.data(runtime);
-    auto offset = array.offset(runtime);
-    auto size = array.size(runtime);
+enum class NativeMask {
+    Type = 1
+};
 
-    auto data = buf + offset;
+enum class NativeType {
+    None,
+    CanvasGradient,
+    CanvasPattern,
+    ImageData,
+    ImageAsset,
+    CanvasRenderingContext2D,
+    WebGLRenderingContextBase,
+    Path2D,
+    Matrix,
+    ImageBitmap,
+    TextMetrics,
 
-    rust::Slice<T> slice(reinterpret_cast<T *>(data), (size / sizeof(T)));
-    return std::move(slice);
+    WebGLQuery,
+    WebGLProgram,
+    WebGLShader,
+    WebGLBuffer,
+    WebGLFramebuffer,
+    WebGLRenderbuffer,
+    WebGLTexture,
+    WebGLActiveInfo,
+    OES_fbo_render_mipmap,
+    EXT_blend_minmax,
+    EXT_color_buffer_half_float,
+    EXT_disjoint_timer_query,
+    EXT_sRGB,
+    EXT_shader_texture_lod,
+    EXT_texture_filter_anisotropic,
+    OES_element_index_uint,
+    OES_standard_derivatives,
+    OES_texture_float,
+    OES_texture_float_linear,
+    OES_texture_half_float_linear,
+    OES_texture_half_float,
+    WEBGL_color_buffer_float,
+    OES_vertex_array_object,
+    WebGLVertexArrayObject,
+    WEBGL_compressed_texture_atc,
+    WEBGL_compressed_texture_etc1,
+    WEBGL_compressed_texture_s3tc,
+    WEBGL_compressed_texture_s3tc_srgb,
+    WEBGL_compressed_texture_etc,
+    WEBGL_compressed_texture_pvrtc,
+    WEBGL_lose_context,
+    ANGLE_instanced_arrays,
+    WEBGL_depth_texture,
+    WEBGL_draw_buffers,
+    WebGLShaderPrecisionFormat,
+    WebGLUniformLocation,
+    WebGLSampler,
+    WebGLTransformFeedback,
+    WebGLSync
+};
+
+inline static v8::Local<v8::String>
+ConvertToV8OneByteString(v8::Isolate *isolate, std::string string) {
+    auto value = new OneByteStringResource(std::move(string));
+    auto ret = v8::String::NewExternalOneByte(isolate, value);
+    return ret.ToLocalChecked();
 }
 
-template<typename T>
-inline static std::shared_ptr<T>
-getHostObject(jsi::Runtime &runtime, const facebook::jsi::Value &value) {
-    if (value.isObject()) {
-        auto valueObject = value.asObject(runtime);
-        try {
-            if (valueObject.template isHostObject(runtime)) {
-                return valueObject.template asHostObject<T>(runtime);
-            }
-        } catch (...) {}
+
+inline static v8::Local<v8::String>
+ConvertToV8OneByteString(v8::Isolate *isolate, char *string) {
+    auto value = new OneByteStringResource(string);
+    auto ret = v8::String::NewExternalOneByte(isolate, value);
+    return ret.ToLocalChecked();
+}
+
+inline static v8::Local<v8::String>
+ConvertToV8String(v8::Isolate *isolate, const std::string &string) {
+    return v8::String::NewFromUtf8(isolate, string.c_str()).ToLocalChecked();
+}
+
+inline static std::string
+ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
+    if (value.IsEmpty()) {
+        return {};
     }
 
-    return nullptr;
+    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};
 }
 
-template<typename T>
-inline static std::shared_ptr<T>
-getHostObject(jsi::Runtime &runtime, const facebook::jsi::Object &value) {
-    if (value.template isHostObject(runtime)) {
-        return value.template asHostObject<T>(runtime);
+
+static void SetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
+                            const v8::Local<v8::String> &propName,
+                            const v8::Local<v8::Value> &value) {
+    v8::Local<v8::Context> context;
+    obj->GetCreationContext().ToLocal(&context);
+    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
+    obj->SetPrivate(context, privateKey, value);
+}
+
+static v8::Local<v8::Value>
+GetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
+                const v8::Local<v8::String> &propName) {
+    v8::Local<v8::Context> context;
+    obj->GetCreationContext().ToLocal(&context);
+    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
+
+    v8::Maybe<bool> hasPrivate = obj->HasPrivate(context, privateKey);
+
+    if (!hasPrivate.FromMaybe(false)) {
+        return v8::Local<v8::Value>();
     }
-    return nullptr;
+
+    v8::Local<v8::Value> result;
+
+    obj->GetPrivate(context, privateKey).ToLocal(&result);
+
+    return result;
+}
+
+static void SetNativeType(const v8::Local<v8::Object> &obj, NativeType type) {
+    auto value = (int32_t) type;
+    obj->SetAlignedPointerInInternalField(1, new int32_t(value));
 }
 
+inline static NativeType GetNativeType(const v8::Local<v8::Value> &obj) {
+    if (!obj->IsNullOrUndefined() && obj->IsObject() &&
+        obj.As<v8::Object>()->InternalFieldCount() > 1) {
+        auto info = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(1);
+
+        if (info != nullptr) {
+            auto value = *static_cast<int32_t *>(info);
+            auto ret = value;
+            if (ret >= (int) NativeType::CanvasGradient &&
+                ret <= (int) NativeType::WebGLSync) {
+                return (NativeType) ret;
+            }
+        }
+    }
+
+    return NativeType::None;
+}
+
+
+//template<class T>
+//static inline void Finalizer(const v8::WeakCallbackInfo<T> &data) {
+//    auto *pThis = data.GetParameter();
+//    pThis->weakHandle_.Reset();
+//    delete pThis;
+//}
+
+//static inline void BindFinalizer(v8::Isolate *isolate, v8::Global<v8::Object> &weakHandle, const v8::Local<v8::Object> &object) {
+//    v8::HandleScope scopedHandle(isolate);
+//    weakHandle.Reset(isolate, object);
+//    weakHandle.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
+//}
+
+
+
+static void SetFastMethod(v8::Isolate *isolate,
+                          v8::Local<v8::Template> that,
+                          const char *name,
+                          v8::FunctionCallback slow_callback,
+                          const v8::CFunction *c_function,
+                          v8::Local<v8::Value> data) {
+    v8::Local<v8::FunctionTemplate> t =
+            v8::FunctionTemplate::New(isolate,
+                                      slow_callback,
+                                      data,
+                                      v8::Local<v8::Signature>(),
+                                      0,
+                                      v8::ConstructorBehavior::kThrow,
+                                      v8::SideEffectType::kHasSideEffect,
+                                      c_function);
+    // kInternalized strings are created in the old space.
+    const v8::NewStringType type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> name_string =
+            v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+    that->Set(name_string, t);
+}
+
+
+#define NUM(a) (sizeof(a) / sizeof(*a))
+
+static void SetFastMethodWithOverLoads(v8::Isolate *isolate,
+                                       v8::Local<v8::Template> that,
+                                       const char *name,
+                                       v8::FunctionCallback slow_callback,
+                                       const v8::CFunction *method_overloads,
+                                       v8::Local<v8::Value> data) {
+
+    auto len = NUM(&method_overloads);
+    v8::Local<v8::FunctionTemplate> t =
+            v8::FunctionTemplate::NewWithCFunctionOverloads(isolate,
+                                                            slow_callback,
+                                                            data,
+                                                            v8::Local<v8::Signature>(),
+                                                            0,
+                                                            v8::ConstructorBehavior::kThrow,
+                                                            v8::SideEffectType::kHasSideEffect,
+                                                            {method_overloads, len});
+    // kInternalized strings are created in the old space.
+    const v8::NewStringType type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> name_string =
+            v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+    that->Set(name_string, t);
+}
+
+
+static void SetFastMethod(v8::Local<v8::Context> context,
+                          v8::Local<v8::Object> that,
+                          const char *name,
+                          v8::FunctionCallback slow_callback,
+                          const v8::CFunction *c_function,
+                          v8::Local<v8::Value> data = v8::Local<v8::Value>()) {
+    v8::Isolate *isolate = context->GetIsolate();
+    v8::Local<v8::Function> function =
+            v8::FunctionTemplate::New(isolate,
+                                      slow_callback,
+                                      data,
+                                      v8::Local<v8::Signature>(),
+                                      0,
+                                      v8::ConstructorBehavior::kThrow,
+                                      v8::SideEffectType::kHasSideEffect,
+                                      c_function)
+                    ->GetFunction(context)
+                    .ToLocalChecked();
+    const v8::NewStringType type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> name_string =
+            v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+    that->Set(context, name_string, function).Check();
+}
+
+static void SetFastMethodNoSideEffect(v8::Local<v8::Context> context,
+                                      v8::Local<v8::Object> that,
+                                      const char *name,
+                                      v8::FunctionCallback slow_callback,
+                                      const v8::CFunction *c_function,
+                                      v8::Local<v8::Value> data) {
+    v8::Isolate *isolate = context->GetIsolate();
+    v8::Local<v8::Function> function =
+            v8::FunctionTemplate::New(isolate,
+                                      slow_callback,
+                                      data,
+                                      v8::Local<v8::Signature>(),
+                                      0,
+                                      v8::ConstructorBehavior::kThrow,
+                                      v8::SideEffectType::kHasNoSideEffect,
+                                      c_function)
+                    ->GetFunction(context)
+                    .ToLocalChecked();
+    const v8::NewStringType type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> name_string =
+            v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+    that->Set(context, name_string, function).Check();
+}
+
+static void SetFastMethodNoSideEffect(v8::Isolate *isolate,
+                                      v8::Local<v8::Template> that,
+                                      const char *name,
+                                      v8::FunctionCallback slow_callback,
+                                      const v8::CFunction *c_function,
+                                      v8::Local<v8::Value> data) {
+    v8::Local<v8::FunctionTemplate> t =
+            v8::FunctionTemplate::New(isolate,
+                                      slow_callback,
+                                      data,
+                                      v8::Local<v8::Signature>(),
+                                      0,
+                                      v8::ConstructorBehavior::kThrow,
+                                      v8::SideEffectType::kHasNoSideEffect,
+                                      c_function);
+    // kInternalized strings are created in the old space.
+    const v8::NewStringType type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> name_string =
+            v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+    that->Set(name_string, t);
+}