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

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

@@ -0,0 +1,36 @@
+//
+// Created by Osei Fortune on 30/09/2023.
+//
+
+#pragma once
+
+#include "Common.h"
+
+class OneByteStringResource : public v8::String::ExternalOneByteStringResource {
+public:
+    OneByteStringResource(char *string);
+
+    OneByteStringResource(U8Buffer *buffer);
+    
+    OneByteStringResource(CCow *cow);
+    
+    OneByteStringResource(std::string string);
+
+    ~OneByteStringResource();
+
+    const char *data() const override;
+
+    size_t length() const override;
+
+private:
+    const char *string_;
+    size_t length_;
+    U8Buffer *buffer_ = nullptr;
+    CCow *cow_ = nullptr;
+    std::string stdString_;
+    // todo enum
+    bool usingBuffer_ = false;
+    bool usingCow_ = false;
+    bool usingString = false;
+};
+

package/platforms/ios/src/cpp/PerIsolateData.cpp

@@ -0,0 +1,49 @@
+//
+//  PerIsolateData.cpp
+//
+//  Created by Osei Fortune on 10/01/2024.
+//  Copyright © 2024 NativeScript. All rights reserved.
+//
+
+#include "PerIsolateData.h"
+
+PerIsolateData::PerIsolateData(v8::Isolate *isolate) {
+    auto type = v8::String::NewFromUtf8(isolate, "__type").ToLocalChecked();
+    INSTANCE_TYPE_PERSISTENT = new v8::Persistent<v8::String>(isolate, type);
+
+    auto version = v8::String::NewFromUtf8(isolate, "version").ToLocalChecked();
+    VERSION_PERSISTENT = new v8::Persistent<v8::String>(isolate, version);
+
+    auto alpha = v8::String::NewFromUtf8(isolate, "alpha").ToLocalChecked();
+    ALPHA_PERSISTENT = new v8::Persistent<v8::String>(isolate, alpha);
+
+    auto antialias = v8::String::NewFromUtf8(isolate, "antialias").ToLocalChecked();
+    ANTIALIAS_PERSISTENT = new v8::Persistent<v8::String>(isolate, antialias);
+
+    auto failIfMajorPerformanceCaveat = v8::String::NewFromUtf8(isolate,
+                                                                "failIfMajorPerformanceCaveat").ToLocalChecked();
+    FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT = new v8::Persistent<v8::String>(isolate,
+                                                                                 failIfMajorPerformanceCaveat);
+
+    auto powerPreference = v8::String::NewFromUtf8(isolate, "powerPreference").ToLocalChecked();
+    POWER_PREFERENCE_PERSISTENT = new v8::Persistent<v8::String>(isolate, powerPreference);
+
+    auto premultipliedAlpha = v8::String::NewFromUtf8(isolate,
+                                                      "premultipliedAlpha").ToLocalChecked();
+    PREMULTIPLIED_ALPHA_PERSISTENT = new v8::Persistent<v8::String>(isolate, premultipliedAlpha);
+
+    auto preserveDrawingBuffer = v8::String::NewFromUtf8(isolate,
+                                                         "preserveDrawingBuffer").ToLocalChecked();
+    PRESERVE_DRAWING_BUFFER_PERSISTENT = new v8::Persistent<v8::String>(isolate,
+                                                                        preserveDrawingBuffer);
+
+    auto stencil = v8::String::NewFromUtf8(isolate, "stencil").ToLocalChecked();
+    STENCIL_PERSISTENT = new v8::Persistent<v8::String>(isolate, stencil);
+
+    auto desynchronized = v8::String::NewFromUtf8(isolate, "desynchronized").ToLocalChecked();
+    DESYNCHRONIZED_PERSISTENT = new v8::Persistent<v8::String>(isolate, desynchronized);
+
+    auto xrCompatible = v8::String::NewFromUtf8(isolate, "xrCompatible").ToLocalChecked();
+    XR_COMPATIBLE_PERSISTENT = new v8::Persistent<v8::String>(isolate, xrCompatible);
+
+}

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

@@ -0,0 +1,54 @@
+//
+//  PerIsolateData.h
+//
+//  Created by Osei Fortune on 10/01/2024.
+//  Copyright © 2024 NativeScript. All rights reserved.
+//
+
+#ifndef PerIsolateData_h
+#define PerIsolateData_h
+
+#include "Common.h"
+
+class PerIsolateData {
+public:
+    PerIsolateData(v8::Isolate *isolate);
+
+    ~PerIsolateData() {
+        INSTANCE_TYPE_PERSISTENT->Reset();
+        VERSION_PERSISTENT->Reset();
+        ALPHA_PERSISTENT->Reset();
+        ANTIALIAS_PERSISTENT->Reset();
+        FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT->Reset();
+        POWER_PREFERENCE_PERSISTENT->Reset();
+        PREMULTIPLIED_ALPHA_PERSISTENT->Reset();
+        PRESERVE_DRAWING_BUFFER_PERSISTENT->Reset();
+        STENCIL_PERSISTENT->Reset();
+        DESYNCHRONIZED_PERSISTENT->Reset();
+        XR_COMPATIBLE_PERSISTENT->Reset();
+    }
+
+    v8::Persistent<v8::String> *INSTANCE_TYPE_PERSISTENT;
+
+    v8::Persistent<v8::String> *VERSION_PERSISTENT;
+
+    v8::Persistent<v8::String> *ALPHA_PERSISTENT;
+
+    v8::Persistent<v8::String> *ANTIALIAS_PERSISTENT;
+
+    v8::Persistent<v8::String> *FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT;
+
+    v8::Persistent<v8::String> *POWER_PREFERENCE_PERSISTENT;
+
+    v8::Persistent<v8::String> *PREMULTIPLIED_ALPHA_PERSISTENT;
+
+    v8::Persistent<v8::String> *PRESERVE_DRAWING_BUFFER_PERSISTENT;
+
+    v8::Persistent<v8::String> *STENCIL_PERSISTENT;
+
+    v8::Persistent<v8::String> *DESYNCHRONIZED_PERSISTENT;
+
+    v8::Persistent<v8::String> *XR_COMPATIBLE_PERSISTENT;
+};
+
+#endif /* PerIsolateData_h */

package/platforms/ios/src/cpp/RafImpl.cpp

@@ -0,0 +1,8 @@
+//
+// Created by Osei Fortune on 20/04/2022.
+//
+
+#include "RafImpl.h"
+
+RafImpl::RafImpl(OnRafCallback *rafCallback, intptr_t callback, Raf* raf) : rafCallback_(
+        rafCallback), callback_(callback), raf_(raf) {}

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

@@ -5,23 +5,26 @@
 #pragma once
 #pragma process_pending_includes
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
 #include <cstdint>
 #include "OnRafCallback.h"
-
-using namespace org::nativescript::canvas;
+#include "Common.h"
 
 class RafImpl {
 public:
-    RafImpl(OnRafCallback *rafCallback, intptr_t callback, rust::Box<Raf> raf);
+    RafImpl(OnRafCallback *rafCallback, intptr_t callback, Raf* raf);
+    
+    ~RafImpl(){
+        canvas_native_raf_destroy(this->GetRaf());
+        this->raf_ = nullptr;
+        delete rafCallback_;
+    }
 
-    Raf &GetRaf() {
-        return *this->raf_;
+    Raf *GetRaf() {
+        return this->raf_;
     }
 
 private:
     OnRafCallback *rafCallback_;
     intptr_t callback_;
-    rust::Box<Raf> raf_;
+    Raf* raf_;
 };

package/platforms/ios/src/cpp/TextDecoderImpl.cpp

@@ -0,0 +1,193 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#include "TextDecoderImpl.h"
+#include "Caches.h"
+#include "Helpers.h"
+#include "OneByteStringResource.h"
+
+TextDecoderImpl::TextDecoderImpl(TextDecoder* decoder) : decoder_(decoder) {}
+
+void TextDecoderImpl::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+   canvasModule->Set(context, ConvertToV8String(isolate, "TextDecoder"), func);
+}
+
+TextDecoderImpl *TextDecoderImpl::GetPointer(v8::Local<v8::Object> object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<TextDecoderImpl *>(ptr);
+}
+
+TextDecoder* TextDecoderImpl::GetTextDecoder() {
+    return this->decoder_;
+}
+
+v8::Local<v8::FunctionTemplate> TextDecoderImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->TextDecoderTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, Ctor);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "TextDecoder"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "encoding"),
+            Encoding);
+    tmpl->Set(
+            ConvertToV8String(isolate, "decode"),
+            v8::FunctionTemplate::New(isolate, &Decode));
+    cache->TextDecoderTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void MyWeakCallback(const v8::WeakCallbackInfo<TextDecoderImpl>& info) {
+    TextDecoderImpl* obj = info.GetParameter();
+    // Perform cleanup or any necessary actions when the object is no longer reachable
+    delete obj;
+}
+
+void TextDecoderImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto value = args[0];
+    auto isolate = args.GetIsolate();
+    if (count == 1 && !value->IsString()) {
+        auto label = value->ToString(isolate->GetCurrentContext()).ToLocalChecked();
+        auto arg = ConvertFromV8String(isolate, label);
+        auto error = "Failed to construct 'TextDecoder': The encoding label provided (" +
+                     arg + "') is invalid";
+        isolate->ThrowError(ConvertToV8String(isolate, error));
+        return;
+    }
+
+    std::string encoding("utf-8");
+    if (count == 1) {
+        encoding = ConvertFromV8String(isolate, value);
+    }
+    auto encoder = canvas_native_text_decoder_create(encoding.c_str());
+
+    auto ret = args.This();
+
+    auto decoder = new TextDecoderImpl(encoder);
+
+    ret->SetAlignedPointerInInternalField(0, decoder);
+
+    decoder->BindFinalizer(isolate, ret);
+
+    args.GetReturnValue().Set(ret);
+
+}
+
+void
+TextDecoderImpl::Encoding(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto encoding = canvas_native_text_decoder_get_encoding(ptr->GetTextDecoder());
+        info.GetReturnValue().Set(ConvertToV8String(isolate, encoding));
+        canvas_native_string_destroy((char*)encoding);
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void TextDecoderImpl::Decode(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    TextDecoderImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetEmptyString();
+        return;
+    }
+    auto isolate = args.GetIsolate();
+
+    if (args.Length() == 1) {
+        auto value = args[0];
+        if (value->IsNull() ||
+            value->IsUndefined() ||
+            !value->IsObject()) {
+
+            args.GetIsolate()->ThrowError(
+                    "Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"
+            );
+            return;
+        }
+
+        auto buf = value.As<v8::Object>();
+
+        if (buf->IsArrayBuffer()) {
+
+            auto buffer = buf.As<v8::ArrayBuffer>();
+
+            auto data = static_cast<u_int8_t *>(buffer->GetBackingStore()->Data());
+            auto size = buffer->ByteLength();
+            auto decoded = canvas_native_text_decoder_decode(
+                    ptr->GetTextDecoder(),
+                    data, size);
+            //args.GetReturnValue().Set(ConvertToV8String(isolate, decoded.c_str()));
+            auto returnValue = new OneByteStringResource((char *)decoded);
+            auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+            args.GetReturnValue().Set(ret.ToLocalChecked());
+
+            return;
+        }
+
+
+        if (buf->IsArrayBufferView()) {
+
+            auto buffer = buf.As<v8::ArrayBufferView>();
+
+
+            auto store = buffer->Buffer()->GetBackingStore();
+            auto buffer_data = static_cast<uint8_t *>(store->Data()) + buffer->ByteOffset();
+
+            auto len = buffer->ByteLength();
+
+//            v8::Local<v8::Value> size;
+//
+//            buf->Get(context, ConvertToV8String(isolate, "BYTES_PER_ELEMENT")).ToLocal(&size);
+//
+//            size_t len = 0;
+//
+//            if(!size.IsEmpty()){
+//                len =  buffer->Length() * (size_t)size->NumberValue(context).FromMaybe(0);
+//            }
+
+          //  auto len = buffer->ByteLength();
+
+            auto decoded = canvas_native_text_decoder_decode_as_cow(
+                    ptr->GetTextDecoder(),
+                                                             buffer_data, len);
+
+
+            // args.GetReturnValue().Set(ConvertToV8String(isolate, decoded.c_str()));
+            auto returnValue = new OneByteStringResource(decoded);
+            auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+            args.GetReturnValue().Set(ret.ToLocalChecked());
+            return;
+        }
+
+
+        args.GetIsolate()->ThrowError(
+                "Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+
+
+    }
+
+    args.GetReturnValue().SetEmptyString();
+}

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

@@ -4,25 +4,35 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#include "NativeScript/JSIRuntime.h"
 #include <vector>
-#include "Helpers.h"
+#include "Common.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT TextDecoderImpl : public jsi::HostObject {
+class TextDecoderImpl: ObjectWrapperImpl {
 public:
-    TextDecoderImpl(rust::Box<TextDecoder> decoder);
+  
+    TextDecoderImpl(TextDecoder *decoder);
+
+    ~TextDecoderImpl() {
+        canvas_native_text_decoder_destroy(this->GetTextDecoder());
+        this->decoder_ = nullptr;
+    }
+
+    TextDecoder *GetTextDecoder();
+
+    static void Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate);
+
+    static TextDecoderImpl *GetPointer(v8::Local<v8::Object> object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void Decode(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    TextDecoder &GetTextDecoder();
+    static void
+    Encoding(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    rust::Box<TextDecoder> decoder_;
+    TextDecoder *decoder_;
 };

package/platforms/ios/src/cpp/TextEncoderImpl.cpp

@@ -0,0 +1,139 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#include "TextEncoderImpl.h"
+#include "Caches.h"
+#include "Helpers.h"
+#include "Common.h"
+
+TextEncoderImpl::TextEncoderImpl(TextEncoder* encoder) : encoder_(encoder) {}
+
+void TextEncoderImpl::Init(const v8::Local<v8::Object>& canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "TextEncoder"), func);
+}
+
+
+TextEncoderImpl *TextEncoderImpl::GetPointer(v8::Local<v8::Object> object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<TextEncoderImpl *>(ptr);
+}
+
+
+v8::Local<v8::FunctionTemplate> TextEncoderImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->TextEncoderTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, Ctor);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "TextEncoder"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "encoding"),
+            Encoding);
+    tmpl->Set(
+            ConvertToV8String(isolate, "encode"),
+            v8::FunctionTemplate::New(isolate, &Encode));
+    cache->TextEncoderTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void TextEncoderImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto value = args[0];
+    auto isolate = args.GetIsolate();
+    if (count == 1 && !value->IsString()) {
+        auto label = value->ToString(isolate->GetCurrentContext()).ToLocalChecked();
+        auto arg = ConvertFromV8String(isolate, label);
+        auto error = "Failed to construct 'TextEncoder': The encoding label provided (" +
+                     arg + "') is invalid";
+        isolate->ThrowError(ConvertToV8String(isolate, error));
+        return;
+    }
+
+    std::string encoding("utf-8");
+    if (count == 1) {
+        encoding = ConvertFromV8String(isolate, value);
+    }
+    auto encoder = canvas_native_text_encoder_create(encoding.c_str());
+
+    auto ret = args.This();
+
+    auto txtEncoder = new TextEncoderImpl(encoder);
+
+    ret->SetAlignedPointerInInternalField(0, txtEncoder);
+
+    txtEncoder->BindFinalizer(isolate, ret);
+
+    args.GetReturnValue().Set(ret);
+
+}
+
+
+void
+TextEncoderImpl::Encoding(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto encoding = canvas_native_text_encoder_get_encoding(ptr->GetTextEncoder());
+        info.GetReturnValue().Set(ConvertToV8String(isolate, encoding));
+        canvas_native_string_destroy((char*)encoding);
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void TextEncoderImpl::Encode(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    TextEncoderImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+    auto isolate = args.GetIsolate();
+
+    auto text = args[0];
+
+    auto encoded = canvas_native_text_encoder_encode(ptr->GetTextEncoder(), ConvertFromV8String(isolate, text).c_str());
+
+    auto data = canvas_native_u8_buffer_get_bytes_mut(encoded);
+
+    auto length = canvas_native_u8_buffer_get_length(encoded);
+
+    auto store = v8::ArrayBuffer::NewBackingStore(data, length,
+                                                  [](void *data, size_t length,
+                                                     void *deleter_data) {
+                                                      if (deleter_data != nullptr) {
+                                                          canvas_native_u8_buffer_destroy((U8Buffer *)deleter_data);
+                                                      }
+                                                  },
+                                                  encoded);
+
+    auto buf = v8::ArrayBuffer::New(isolate, std::move(store));
+
+    auto ret = v8::Uint8ClampedArray::New(buf, 0, length);
+
+    args.GetReturnValue().Set(ret);
+}
+
+TextEncoder* TextEncoderImpl::GetTextEncoder() {
+    return this->encoder_;
+}

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

@@ -4,25 +4,34 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#include "VecMutableBuffer.h"
 #include <vector>
+#include "Common.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT TextEncoderImpl : public jsi::HostObject {
+class TextEncoderImpl: ObjectWrapperImpl {
 
 public:
-    TextEncoderImpl(rust::Box<TextEncoder> encoder);
+    TextEncoderImpl(TextEncoder* encoder);
+    ~TextEncoderImpl() {
+        canvas_native_text_encoder_destroy(this->GetTextEncoder());
+        this->encoder_ = nullptr;
+    }
+
+    TextEncoder* GetTextEncoder();
+    
+    static void Init(const v8::Local<v8::Object>& canvasModule, v8::Isolate *isolate);
+
+    static TextEncoderImpl *GetPointer(v8::Local<v8::Object> object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void Encode(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    TextEncoder &GetTextEncoder();
+    static void
+    Encoding(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    rust::Box<TextEncoder> encoder_;
+    TextEncoder* encoder_;
 };