@nativescript/canvas 2.0.0-rc.2 → 2.0.0-rc.20

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

@@ -48,5 +48,11 @@ public:
     static void AddFontFamily(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void AddFontData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Base64Encode(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Base64Decode(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Base64DecodeAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
 };
 

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

@@ -112,7 +112,6 @@ ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
     return {*result};
 }
 
-
 inline static std::string_view
 ConvertFromV8StringView(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
     if (value.IsEmpty()) {
@@ -121,7 +120,29 @@ ConvertFromV8StringView(v8::Isolate *isolate, const v8::Local<v8::Value> &value)
 
     if (value->IsStringObject()) {
         v8::Local<v8::String> obj = value.As<v8::StringObject>()->ValueOf();
-        return ConvertFromV8String(isolate, obj);
+        return ConvertFromV8StringView(isolate, obj);
+    }
+
+    v8::String::Utf8Value result(isolate, value);
+
+    const char *val = *result;
+
+    if (val == nullptr) {
+        return {};
+    }
+
+    return {*result};
+}
+
+inline static std::string_view
+ConvertFromV8StringViewValue(v8::Isolate *isolate, v8::Local<v8::Value> value) {
+    if (value.IsEmpty()) {
+        return {};
+    }
+
+    if (value->IsStringObject()) {
+        v8::Local<v8::String> obj = value.As<v8::StringObject>()->ValueOf();
+        return ConvertFromV8StringViewValue(isolate, obj);
     }
 
     v8::String::Utf8Value result(isolate, value);

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

@@ -81,7 +81,9 @@ enum class NativeType {
     GPUComputePipeline,
     GPUSampler,
     GPURenderBundleEncoder,
-    GPURenderBundle
+    GPURenderBundle,
+    GPUCompilationInfo,
+    GPUCompilationMessage
 };
 
 #endif //CANVAS_ANDROID_NATIVETYPE_H

package/platforms/ios/src/cpp/OnRafCallback.cpp

@@ -5,21 +5,26 @@
 #include "OnRafCallback.h"
 #include "canvas2d/CanvasRenderingContext2DImpl.h"
 #include "webgl/WebGLRenderingContextBase.h"
+#include "webgpu/GPUCanvasContextImpl.h"
 
 OnRafCallback::OnRafCallback(intptr_t context, uint32_t version) : context_(context),
-                                                                   version_(version) {}
+version_(version) {}
 
 void OnRafCallback::OnFrame(int64_t ts) const {
-    if (this->version_ == 0) {
-        CanvasRenderingContext2DImpl::Flush(this->context_);
-    }
-
-    if (this->version_ == 1 || this->version_ == 2) {
-        WebGLRenderingContextBase::Flush(this->context_);
-    }
+	if (this->version_ == 0) {
+		CanvasRenderingContext2DImpl::Flush(this->context_);
+	}
+	
+	if (this->version_ == 1 || this->version_ == 2) {
+		WebGLRenderingContextBase::Flush(this->context_);
+	}
+	
+	if(this->version_ == 3){
+		GPUCanvasContextImpl::Flush(this->context_);
+	}
 }
 
 void OnRafCallbackOnFrame(intptr_t callback, int64_t ts) {
-    auto ptr = reinterpret_cast<OnRafCallback *>(reinterpret_cast<intptr_t *>(callback));
-    ptr->OnFrame(ts);
+	auto ptr = reinterpret_cast<OnRafCallback *>(reinterpret_cast<intptr_t *>(callback));
+	ptr->OnFrame(ts);
 }

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

@@ -11,6 +11,7 @@ class OnRafCallback {
     // 0 2d
     // 1 gl
     // 2 gl2
+		// 3 gpu
 public:
     OnRafCallback(intptr_t context, uint32_t version);
 

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

@@ -35,6 +35,7 @@ struct PromiseCallback {
         CompleteCallback completeCallbackWrapper_;
         bool isPrepared_ = false;
         void* data;
+        mutable std::mutex mtx;
 
         Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
               CompleteCallback completeCallback) : isolate_(isolate),
@@ -45,25 +46,37 @@ struct PromiseCallback {
             this->completeCallbackWrapper_ = [](bool success, void *data){
                 if(data != nullptr){
                     auto* callback = static_cast<PromiseCallback*>(data);
-                    auto inner = callback->inner_.get();
-                    if(inner == nullptr || inner->current_queue != nullptr){
+                    if(callback->inner_ == nullptr || callback->inner_->current_queue == nullptr){
                         return;
                     }
 
-                    inner->current_queue->addOperation([success, data, inner, callback](){
-                        inner->completeCallback_(success, data);
+                    callback->inner_->current_queue->addOperation([success, data, callback](){
+                        callback->inner_->completeCallback_(success, data);
                      //   delete callback;
                     });
                 }
             };
         }
 
+        void setData(void* newData) {
+              std::lock_guard<std::mutex> lock(mtx);
+              data = newData;
+        }
+
+
+        void* getData() {
+            std::lock_guard<std::mutex> lock(mtx);
+            return data;
+        }
+
         void prepare(){
+            std::lock_guard<std::mutex> lock(mtx);
             current_queue = new NSOperationQueueWrapper(true);
             isPrepared_ = true;
         }
 
         void execute(bool complete, PromiseCallback* callback){
+            std::lock_guard<std::mutex> lock(mtx);
            completeCallbackWrapper_(complete, callback);
         }
 
@@ -76,15 +89,13 @@ struct PromiseCallback {
     std::shared_ptr<Inner> inner_;
 
     void prepare(){
-       auto inner = this->inner_.get();
-       if(inner == nullptr){return;}
-        inner->prepare();
+       if( this->inner_ == nullptr){return;}
+        this->inner_->prepare();
     }
 
         void execute(bool complete) {
-        auto inner = this->inner_.get();
-        if (inner == nullptr) { return; }
-        inner->execute(complete, this);
+        if (this->inner_ == nullptr) { return; }
+            this->inner_->execute(complete, this);
     }
 
     explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
@@ -106,6 +117,7 @@ struct PromiseCallback {
         void *data = nullptr;
         CompleteCallback completeCallback_;
         bool isPrepared_ = false;
+        mutable std::mutex mtx;
 
         Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
               CompleteCallback completeCallback) : isolate_(isolate),
@@ -135,13 +147,25 @@ struct PromiseCallback {
             isPrepared_ = true;
         }
 
-        void execute(bool complete) const {
+        void execute(bool complete, [[maybe_unused]] PromiseCallback *callback) const {
             if (!isPrepared_) { return; }
             write(fd_[1],
                   &complete,
                   sizeof(bool));
         }
 
+        void setData(void *newData) {
+            std::lock_guard<std::mutex> lock(mtx);
+            data = newData;
+        }
+
+
+        void *getData() {
+            std::lock_guard<std::mutex> lock(mtx);
+            return data;
+        }
+
+
 
         ~Inner() {
             if (!isPrepared_) {
@@ -155,11 +179,10 @@ struct PromiseCallback {
     };
 
     void prepare() const {
-        auto inner = this->inner_.get();
-        if (inner == nullptr) { return; }
-        inner->prepare();
-        auto looper = inner->looper_;
-        auto fd = inner->fd_[0];
+        if (inner_ == nullptr) { return; }
+        inner_->prepare();
+        auto looper = inner_->looper_;
+        auto fd = inner_->fd_[0];
         auto data = new PromiseCallback(this->inner_);
         ALooper_addFd(looper,
                       fd,
@@ -175,13 +198,12 @@ struct PromiseCallback {
                           return 0;
                       }, (void *) data);
 
-        inner->isPrepared_ = true;
+        inner_->isPrepared_ = true;
     }
 
     void execute(bool complete) const {
-        auto inner = this->inner_.get();
-        if (inner == nullptr) { return; }
-        inner->execute(complete);
+        if (this->inner_ == nullptr) { return; }
+        this->inner_->execute(complete, nullptr);
     }
 
     std::shared_ptr<Inner> inner_;

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

@@ -52,6 +52,12 @@ v8::Local<v8::FunctionTemplate> TextDecoderImpl::GetCtor(v8::Isolate *isolate) {
     tmpl->Set(
             ConvertToV8String(isolate, "decode"),
             v8::FunctionTemplate::New(isolate, &Decode));
+    
+    tmpl->Set(
+            ConvertToV8String(isolate, "decodeAsync"),
+            v8::FunctionTemplate::New(isolate, &DecodeAsync));
+    
+    
     cache->TextDecoderTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
@@ -185,3 +191,139 @@ void TextDecoderImpl::Decode(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     args.GetReturnValue().SetEmptyString();
 }
+
+struct DecodeAsyncData {
+    v8::Persistent<v8::Object>* buffer;
+    uint8_t* data;
+    size_t size;
+};
+
+void TextDecoderImpl::DecodeAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+
+    auto resolver = v8::Promise::Resolver::New(isolate->GetCurrentContext()).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+    
+    auto context = isolate->GetCurrentContext();
+    
+    auto value = args[0];
+    if (value->IsNull() ||
+        value->IsUndefined() ||
+        !value->IsObject()) {
+        
+        auto msg = v8::Exception::Error(ConvertToV8String(isolate, "Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"));
+        
+        resolver->Reject(context, msg);
+
+        return;
+    }
+    
+    TextDecoderImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        resolver->Resolve(context, v8::String::Empty(isolate));
+        return;
+    }
+    
+    if(!value->IsArrayBufferView() && !value->IsArrayBuffer()){
+        
+        auto msg = v8::Exception::Error(ConvertToV8String(isolate, "Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"));
+        
+        resolver->Reject(context, msg);
+        return;
+    }
+
+
+    auto callback = new PromiseCallback{
+            isolate,
+            resolver,
+            [](bool done, void *data) {
+                auto async_data = static_cast<PromiseCallback *>(data);
+                auto func = async_data->inner_;
+                if (func != nullptr && func->isolate_ != nullptr) {
+                    v8::Isolate *isolate = func->isolate_;
+                    v8::Locker locker(isolate);
+                    v8::Isolate::Scope isolate_scope(
+                            isolate);
+                    v8::HandleScope handle_scope(
+                            isolate);
+                    v8::Local<v8::Promise::Resolver> callback = func->callback_.Get(
+                            isolate);
+                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                    v8::Context::Scope context_scope(
+                            context);
+
+                    auto funcData = func->getData();
+
+                    if (funcData == nullptr) {
+                        callback->Resolve(context, v8::String::Empty(isolate));
+                    } else {
+                        auto decoded = static_cast<CCow *>(funcData);
+
+                        auto returnValue = new OneByteStringResource(decoded);
+                        auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+                        v8::Local<v8::Value> value;
+                        func->setData(nullptr);
+
+                        
+                        if (ret.ToLocal(&value)){
+                            callback->Resolve(context, value).IsJust();
+                        } else {
+                            callback->Resolve(context, v8::String::Empty(isolate)).IsJust();
+                        }
+                    }
+                }
+
+                delete static_cast<PromiseCallback *>(data);
+            }
+    };
+    callback->prepare();
+    
+    
+    auto buf = value.As<v8::Object>();
+    
+    auto bufferPer = new v8::Persistent<v8::Object>(isolate, buf);
+    
+    uint8_t* data = nullptr;
+    size_t size;
+    
+    if (buf->IsArrayBuffer()) {
+        auto buffer = buf.As<v8::ArrayBuffer>();
+        data = static_cast<u_int8_t *>(buffer->GetBackingStore()->Data());
+        size = buffer->ByteLength();
+    }
+
+
+    if (buf->IsArrayBufferView()) {
+        auto buffer = buf.As<v8::ArrayBufferView>();
+
+        auto store = buffer->Buffer()->GetBackingStore();
+        data = static_cast<uint8_t *>(store->Data()) + buffer->ByteOffset();
+
+        size = buffer->ByteLength();
+    }
+
+    DecodeAsyncData asyncData{
+        bufferPer,
+        data,
+        size
+    };
+    
+
+    std::thread thread(
+            [callback, asyncData, ptr]() {
+                if (callback->inner_ != nullptr) {
+                    
+                    auto decoded = canvas_native_text_decoder_decode_as_cow(
+                            ptr->GetTextDecoder(),
+                                                                            asyncData.data, asyncData.size);
+                    
+                    callback->inner_->setData(decoded);
+                    callback->inner_->execute(true, callback);
+                }
+                asyncData.buffer->Reset();
+                delete asyncData.buffer;
+                
+            });
+    thread.detach();
+
+}

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

@@ -29,6 +29,8 @@ public:
     static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void Decode(const v8::FunctionCallbackInfo<v8::Value> &args);
+    
+    static void DecodeAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
     Encoding(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);

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

@@ -1147,11 +1147,8 @@ void CanvasRenderingContext2DImpl::GetGlobalCompositeOperation(v8::Local<v8::Str
         info.GetReturnValue().Set(0);
         return;
     }
-    auto operation = canvas_native_context_get_global_composition(ptr->GetContext());
-    info.GetReturnValue().Set(
-            ConvertToV8String(info.GetIsolate(), operation));
-
-    canvas_native_string_destroy((char *) operation);
+    auto operation = canvas_native_context_get_global_composition_int(ptr->GetContext());
+		info.GetReturnValue().Set(operation);
 }
 
 void CanvasRenderingContext2DImpl::SetGlobalCompositeOperation(v8::Local<v8::String> property,
@@ -1162,8 +1159,15 @@ void CanvasRenderingContext2DImpl::SetGlobalCompositeOperation(v8::Local<v8::Str
         return;
     }
     auto isolate = info.GetIsolate();
-    auto operation = ConvertFromV8String(isolate, value);
-    canvas_native_context_set_global_composition(ptr->GetContext(), operation.c_str());
+	
+	uint32_t operation = 0;
+	auto context = isolate->GetCurrentContext();
+	if (value->Uint32Value(context).To(&operation)) {
+		canvas_native_context_set_global_composition_int(ptr->GetContext(), operation);
+	}
+	
+//    auto operation = ConvertFromV8String(isolate, value);
+//    canvas_native_context_set_global_composition(ptr->GetContext(), operation.c_str());
 }
 
 
@@ -1220,10 +1224,33 @@ void CanvasRenderingContext2DImpl::SetFillStyle(v8::Local<v8::String> property,
     auto isolate = info.GetIsolate();
 
     if (value->IsString()) {
-        auto style = ConvertFromV8String(isolate, value);
-        canvas_native_paint_style_set_fill_color_with_c_string(ptr->GetContext(),
-                                                               style.c_str());
-    } else if (value->IsObject()) {
+//        auto style = ConvertFromV8String(isolate, value);
+			
+			auto val = value.As<v8::String>();
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+		//	v8::String::Utf8Value result(isolate, value);
+
+//			const char *val = *result;
+
+//			if (buffer == nullptr) {
+//					return;
+//			}
+		
+			canvas_native_paint_style_set_fill_color_with_c_string(ptr->GetContext(), buffer);
+		}else if(value->IsStringObject()){
+			
+			auto val = value.As<v8::StringObject>()->ValueOf();
+			
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+			canvas_native_paint_style_set_fill_color_with_c_string(ptr->GetContext(), buffer);
+			
+		} else if (value->IsObject()) {
 
         auto type = GetNativeType(value);
 
@@ -1300,10 +1327,27 @@ void CanvasRenderingContext2DImpl::SetStrokeStyle(v8::Local<v8::String> property
     auto isolate = info.GetIsolate();
 
     if (value->IsString()) {
-        auto style = ConvertFromV8String(isolate, value);
-        canvas_native_paint_style_set_stroke_color_with_c_string(ptr->GetContext(),
-                                                                 style.c_str());
-    } else if (value->IsObject()) {
+//        auto style = ConvertFromV8String(isolate, value);
+
+			auto val = value.As<v8::String>();
+			
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+			
+			canvas_native_paint_style_set_stroke_color_with_c_string(ptr->GetContext(), buffer);
+			
+		}else if(value->IsStringObject()){
+			auto val = value.As<v8::StringObject>()->ValueOf();
+			
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+			
+			canvas_native_paint_style_set_stroke_color_with_c_string(ptr->GetContext(), buffer);
+		} else if (value->IsObject()) {
 
         auto type = GetNativeType(value);
 

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

@@ -355,7 +355,7 @@ void Path2D::RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args) {
                 auto array = radii.As<v8::Array>();
                 auto size = array->Length();
 
-                if (size > 1) {
+                if (size >= 1) {
                     std::vector<float> store;
                     store.reserve(size);
                     for (int i = 0;

package/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp

@@ -209,11 +209,8 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
         v8::Local<v8::Value> requiredFeaturesValue;
 
-        options->Get(context, ConvertToV8String(isolate, "requiredFeatures")).ToLocal(
-                &requiredFeaturesValue);
-
-
-        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsArray()) {
+        if ( options->Get(context, ConvertToV8String(isolate, "requiredFeatures")).ToLocal(
+																																													 &requiredFeaturesValue) && requiredFeaturesValue->IsArray()) {
             v8::Local<v8::Array> requiredFeatures = requiredFeaturesValue.As<v8::Array>();
             auto len = requiredFeatures->Length();
             for (int i = 0; i < len; i++) {
@@ -229,10 +226,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
         v8::Local<v8::Value> limitsValue;
 
-        options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
-                &limitsValue);
 
-        if (!limitsValue.IsEmpty() && limitsValue->IsObject()) {
+        if (options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
+																																												&limitsValue) && limitsValue->IsObject()) {
             auto limits_ptr = GPUSupportedLimitsImpl::GetPointer(limitsValue.As<v8::Object>());
             if (limits_ptr != nullptr) {
                 limits = limits_ptr->GetLimits();