@nativescript/canvas 2.0.0-alpha.20 → 2.0.0-alpha.21

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

@@ -0,0 +1,188 @@
+//
+// 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->GetInternalField(0).As<v8::External>()->Value();
+    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(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "TextDecoder"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    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 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);
+
+    auto ext = v8::External::New(isolate, decoder);
+
+    ret->SetInternalField(0, ext);
+
+    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();
+    auto context = isolate->GetCurrentContext();
+
+    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(
+                    ptr->GetTextDecoder(),
+                                                             buffer_data, len);
+        
+
+            // 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;
+        }
+
+
+        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

@@ -3,26 +3,32 @@
 //
 
 #pragma once
-
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#include <NativeScript/JSIRuntime.h>
 #include <vector>
-#include "Helpers.h"
-
-using namespace facebook;
-using namespace org::nativescript::canvas;
+#include "Common.h"
 
-class JSI_EXPORT TextDecoderImpl : public jsi::HostObject {
+class TextDecoderImpl {
 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->GetInternalField(0).As<v8::External>()->Value();
+    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(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "TextEncoder"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    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);
+
+    auto ext = v8::External::New(isolate, txtEncoder);
+
+    ret->SetInternalField(0, ext);
+
+    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"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
 
-class JSI_EXPORT TextEncoderImpl : public jsi::HostObject {
+class TextEncoderImpl {
 
 public:
-    TextEncoderImpl(rust::Box<TextEncoder> encoder);
+    TextEncoderImpl(TextEncoder* encoder);
+    ~TextEncoderImpl() {
+        canvas_native_text_encoder_destroy(this->GetTextEncoder());
+        this->encoder_ = nullptr;
+    }
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    TextEncoder* GetTextEncoder();
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void Init(const v8::Local<v8::Object>& canvasModule, v8::Isolate *isolate);
 
-    TextEncoder &GetTextEncoder();
+    static TextEncoderImpl *GetPointer(v8::Local<v8::Object> object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Encode(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    Encoding(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    rust::Box<TextEncoder> encoder_;
+    TextEncoder* encoder_;
 };

package/platforms/ios/src/cpp/canvas2d/CanvasGradient.cpp

@@ -0,0 +1,71 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#include "CanvasGradient.h"
+#include "Helpers.h"
+#include "Caches.h"
+
+CanvasGradient::CanvasGradient(PaintStyle* style) : style_(style) {}
+
+void CanvasGradient::Init(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, "CanvasGradient"), func);
+}
+
+CanvasGradient *CanvasGradient::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<CanvasGradient *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> CanvasGradient::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->CanvasGradientTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "CanvasGradient"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    tmpl->Set(
+            ConvertToV8String(isolate, "addColorStop"),
+            v8::FunctionTemplate::New(isolate, &AddColorStop));
+
+    cache->CanvasGradientTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void CanvasGradient::AddColorStop(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasGradient *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto stop = (float) args[0]->NumberValue(context).ToChecked();
+    auto color = ConvertFromV8String(isolate, args[1]);
+    canvas_native_gradient_add_color_stop(
+            ptr->GetPaintStyle(), stop, color.c_str());
+}
+
+PaintStyle *CanvasGradient::GetPaintStyle() {
+    return this->style_;
+}
+

package/platforms/ios/src/cpp/canvas2d/CanvasGradient.h

@@ -3,26 +3,40 @@
 //
 
 #pragma once
-
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import <NativeScript/JSIRuntime.h>
 #include <vector>
+#include "Common.h"
+#include "Helpers.h"
+class CanvasGradient {
+public:
+    CanvasGradient(PaintStyle*style);
+    
+    ~CanvasGradient(){
+        canvas_native_paint_style_destroy(this->GetPaintStyle());
+        this->style_ = nullptr;
+    }
 
-using namespace facebook;
-using namespace ::org::nativescript::canvas;
+    PaintStyle * GetPaintStyle();
 
-class JSI_EXPORT CanvasGradient : public jsi::HostObject {
-public:
-    CanvasGradient(rust::Box<PaintStyle> style);
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static CanvasGradient *GetPointer(const v8::Local<v8::Object> &object);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasGradient *gradient) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = CanvasGradient::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::CanvasGradient);
+        auto ext = v8::External::New(isolate, gradient);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
 
-    PaintStyle &GetPaintStyle();
+    static void AddColorStop(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    rust::Box<PaintStyle> style_;
+    PaintStyle* style_;
 };
 

package/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp

@@ -0,0 +1,89 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#include "CanvasPattern.h"
+#include "Helpers.h"
+#include "Caches.h"
+
+CanvasPattern::CanvasPattern(PaintStyle* style) : style_(style) {}
+
+void CanvasPattern::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, "CanvasPattern"), func);
+}
+
+CanvasPattern *CanvasPattern::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<CanvasPattern *>(ptr);
+}
+
+static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasPattern *pattern) {
+    auto context = isolate->GetCurrentContext();
+    v8::EscapableHandleScope scope(isolate);
+    auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
+            context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+    SetNativeType(isolate, object, NativeType::CanvasPattern);
+    auto ext = v8::External::New(isolate, pattern);
+    object->SetInternalField(0, ext);
+    return scope.Escape(object);
+}
+
+v8::Local<v8::FunctionTemplate> CanvasPattern::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->CanvasPatternTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "CanvasPattern"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    tmpl->Set(
+            ConvertToV8String(isolate, "SetTransform"),
+            v8::FunctionTemplate::New(isolate, &SetTransform));
+
+    cache->CanvasPatternTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void CanvasPattern::SetTransform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasPattern *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::Matrix) {
+
+        auto matrix = MatrixImpl::GetPointer(value.As<v8::Object>());
+        if (matrix != nullptr) {
+            canvas_native_pattern_set_transform(
+                    ptr->GetPaintStyle(),
+                    matrix->GetMatrix());
+        }
+    }
+
+}
+
+PaintStyle* CanvasPattern::GetPaintStyle() {
+    return this->style_;
+}

package/platforms/ios/src/cpp/canvas2d/CanvasPattern.h

@@ -3,27 +3,40 @@
 //
 
 #pragma once
-
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import <NativeScript/JSIRuntime.h>
 #include "MatrixImpl.h"
 #include <vector>
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT CanvasPattern : public jsi::HostObject {
+class CanvasPattern {
 public:
-    CanvasPattern(rust::Box<PaintStyle> style);
+    CanvasPattern(PaintStyle* style);
+    
+    ~CanvasPattern() {
+        canvas_native_paint_style_destroy(this->GetPaintStyle());
+        this->style_ = nullptr;
+    }
+
+    PaintStyle* GetPaintStyle();
+
+    static void Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate);
+
+    static CanvasPattern *GetPointer(const v8::Local<v8::Object> &object);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, CanvasPattern *pattern) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::CanvasPattern);
+        auto ext = v8::External::New(isolate, pattern);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    PaintStyle &GetPaintStyle();
+    static void SetTransform(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    rust::Box<PaintStyle> style_;
+    PaintStyle* style_;
 };