@nativescript/canvas 2.0.0-rc.5 → 2.0.0-rc.6

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

@@ -199,6 +199,18 @@ void CanvasJSIModule::install(v8::Isolate *isolate) {
                        v8::FunctionTemplate::New(isolate, &AddFontData)->GetFunction(
                                context).ToLocalChecked()).FromJust();
 
+        canvasMod->Set(context, ConvertToV8String(isolate, "__base64Encode"),
+                       v8::FunctionTemplate::New(isolate, &Base64Encode)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
+
+        canvasMod->Set(context, ConvertToV8String(isolate, "__base64Decode"),
+                       v8::FunctionTemplate::New(isolate, &Base64Decode)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
+
+        canvasMod->Set(context, ConvertToV8String(isolate, "__base64DecodeAsync"),
+                       v8::FunctionTemplate::New(isolate, &Base64DecodeAsync)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
+
         global->Set(context,
                     ConvertToV8String(isolate, "CanvasModule"), canvasMod).FromJust();
 
@@ -238,7 +250,6 @@ void CanvasJSIModule::AddFontFamily(const v8::FunctionCallbackInfo<v8::Value> &a
 
 void CanvasJSIModule::AddFontData(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
     auto aliasValue = args[0];
     auto dataValue = args[1];
 
@@ -279,9 +290,168 @@ void CanvasJSIModule::AddFontData(const v8::FunctionCallbackInfo<v8::Value> &arg
 
 }
 
+void CanvasJSIModule::Base64Encode(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto dataValue = args[0];
+
+    auto data = ConvertFromV8StringView(isolate, dataValue);
+
+    if (data.empty()) {
+        args.GetReturnValue().SetEmptyString();
+    } else {
+        auto encoded = canvas_native_helper_base64_encode((const uint8_t *) data.data(),
+                                                          data.size());
+        if (encoded == nullptr) {
+            args.GetReturnValue().SetEmptyString();
+            return;
+        }
+        auto returnValue = new OneByteStringResource(encoded);
+        auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+        v8::Local<v8::Value> value;
+        if (ret.ToLocal(&value)) {
+            args.GetReturnValue().Set(value);
+        } else {
+            args.GetReturnValue().SetEmptyString();
+        }
+
+    }
+}
+
+void CanvasJSIModule::Base64Decode(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto dataValue = args[0];
+
+    auto data = ConvertFromV8StringView(isolate, dataValue);
+
+    if (data.empty()) {
+        args.GetReturnValue().SetEmptyString();
+    } else {
+        auto decoded = canvas_native_helper_base64_decode((const uint8_t *) data.data(),
+                                                          data.size());
+        if (decoded == nullptr) {
+            args.GetReturnValue().SetEmptyString();
+            return;
+        }
+        auto returnValue = new OneByteStringResource(decoded);
+        auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+        v8::Local<v8::Value> value;
+        auto decoded_clone = canvas_native_u8_buffer_clone(decoded);
+        auto buffer_ptr = canvas_native_u8_buffer_get_bytes(decoded_clone);
+        auto buffer_len = canvas_native_u8_buffer_get_length(decoded_clone);
+        auto buffer = v8::ArrayBuffer::NewBackingStore((void *) buffer_ptr, buffer_len,
+                                                       [](void *data,
+                                                          size_t length,
+                                                          void *deleter_data) {
+                                                           if (deleter_data !=
+                                                               nullptr) {
+                                                               canvas_native_u8_buffer_release(
+                                                                       (U8Buffer *) deleter_data);
+                                                           }
+                                                       },
+                                                       (void *) decoded_clone);
+
+        if (ret.ToLocal(&value)) {
+            v8::Local<v8::Value> retArgs[2] = {value,
+                                               v8::ArrayBuffer::New(isolate, std::move(buffer))};
+            args.GetReturnValue().Set(v8::Array::New(isolate, retArgs, 2));
+        } else {
+            args.GetReturnValue().Set(v8::Array::New(isolate));
+        }
+
+    }
+}
+
+void CanvasJSIModule::Base64DecodeAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto dataValue = args[0];
+
+    auto resolver = v8::Promise::Resolver::New(isolate->GetCurrentContext()).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    v8::String::Utf8Value utf8(isolate, dataValue);
+    std::string data(*utf8);
+
+    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<U8Buffer *>(funcData);
+
+                        auto returnValue = new OneByteStringResource(decoded);
+                        auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+                        v8::Local<v8::Value> value;
+                        auto decoded_clone = canvas_native_u8_buffer_clone(decoded);
+
+                        func->setData(nullptr);
+
+                        auto buffer_ptr = canvas_native_u8_buffer_get_bytes(decoded_clone);
+                        auto buffer_len = canvas_native_u8_buffer_get_length(decoded_clone);
+                        auto buffer = v8::ArrayBuffer::NewBackingStore((void *) buffer_ptr,
+                                                                       buffer_len,
+                                                                       [](void *data,
+                                                                          size_t length,
+                                                                          void *deleter_data) {
+                                                                           if (deleter_data !=
+                                                                               nullptr) {
+                                                                               canvas_native_u8_buffer_release(
+                                                                                       (U8Buffer *) deleter_data);
+                                                                           }
+                                                                       },
+                                                                       (void *) decoded_clone);
+
+                        if (ret.ToLocal(&value)) {
+                            v8::Local<v8::Value> retArgs[2] = {value,
+                                                               v8::ArrayBuffer::New(isolate,
+                                                                                    std::move(
+                                                                                            buffer))};
+                            callback->Resolve(context,
+                                              v8::Array::New(isolate, retArgs, 2)).IsJust();
+                        } else {
+                            callback->Resolve(context, v8::Array::New(isolate)).IsJust();
+                        }
+                    }
+                }
+
+                delete static_cast<PromiseCallback *>(data);
+            }
+    };
+    callback->prepare();
+
+    std::thread thread(
+            [callback](std::string data) {
+                if (callback->inner_ != nullptr) {
+                    auto decoded = canvas_native_helper_base64_decode((const uint8_t *) data.data(),
+                                                                      data.size());
+                    callback->inner_->setData(decoded);
+                    callback->inner_->execute(true, callback);
+                }
+            }, std::move(data));
+    thread.detach();
+
+}
+
 void CanvasJSIModule::Create2DContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
     auto ptr = args[0].As<v8::BigInt>()->Int64Value();
 
     auto context_2d = static_cast<CanvasRenderingContext2D *>((void *) ptr);

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,6 +112,50 @@ 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()) {
+        return {};
+    }
+
+    if (value->IsStringObject()) {
+        v8::Local<v8::String> obj = value.As<v8::StringObject>()->ValueOf();
+        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);
+
+    const char *val = *result;
+
+    if (val == nullptr) {
+        return {};
+    }
+
+    return {*result};
+}
+
 
 static void SetFastMethod(v8::Isolate *isolate,
                           v8::Local<v8::Template> that,

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/webgpu/GPUQueueImpl.cpp

@@ -199,6 +199,7 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
         auto textureVal = destinationObj->Get(context, ConvertToV8String(isolate,
                                                                          "texture")).ToLocalChecked();
         auto texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
+        
 
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};