@nativescript/canvas 2.0.0-webgpu.34 → 2.0.0-webgpu.36

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

@@ -178,6 +178,10 @@ void CanvasJSIModule::install(v8::Isolate *isolate) {
                        v8::FunctionTemplate::New(isolate, &ReadFile)->GetFunction(
                                context).ToLocalChecked()).FromJust();
 
+        canvasMod->Set(context, ConvertToV8String(isolate, "getMime"),
+                       v8::FunctionTemplate::New(isolate, &GetMime)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
+
         canvasMod->Set(context, ConvertToV8String(isolate, "createWebGLContext"),
                        v8::FunctionTemplate::New(isolate, &CreateWebGLContext)->GetFunction(
                                context).ToLocalChecked()).FromJust();
@@ -233,7 +237,7 @@ void CanvasJSIModule::Create2DContext(const v8::FunctionCallbackInfo<v8::Value>
     auto context = isolate->GetCurrentContext();
     auto ptr = args[0].As<v8::BigInt>()->Int64Value();
 
-    auto context_2d = static_cast<CanvasRenderingContext2D *>((void *)ptr);
+    auto context_2d = static_cast<CanvasRenderingContext2D *>((void *) ptr);
 
     auto ret = CanvasRenderingContext2DImpl::NewInstance(isolate, new CanvasRenderingContext2DImpl(
             context_2d));
@@ -358,7 +362,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                         isolate, ta);
 
                 auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
-                    if(data == nullptr){return;}
+                    if (data == nullptr) { return; }
                     auto async_data = static_cast<AsyncCallback *>(data);
                     auto func = async_data->inner_.get();
                     if (func != nullptr && func->isolate_ != nullptr) {
@@ -598,7 +602,7 @@ void CanvasJSIModule::Create2DContextWithPointer(const v8::FunctionCallbackInfo<
 
 struct FileData {
     char *error_;
-    U8Buffer* data;
+    U8Buffer *data;
 
     ~FileData() {
         if (error_ != nullptr) {
@@ -613,9 +617,133 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto file = ConvertFromV8String(isolate, args[0]);
     auto cbFunc = args[1].As<v8::Function>();
 
+    auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
+        if (data == nullptr) { return; }
+        auto async_data = static_cast<AsyncCallback *>(data);
+        auto func = async_data->inner_.get();
+        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::Function> callback = func->callback_.Get(
+                    isolate);
+            v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+            v8::Context::Scope context_scope(context);
+
+            if (func->data != nullptr) {
+                auto file_data = static_cast<FileData *>(func->data);
+
+                v8::Local<v8::Value> args[2];
+
+                if (done) {
+                    args[0] = v8::Null(isolate);
+
+                    auto buf = canvas_native_u8_buffer_get_bytes_mut(file_data->data);
+                    auto size = (size_t) canvas_native_u8_buffer_get_length(file_data->data);
+
+                    auto store = v8::ArrayBuffer::NewBackingStore((void *) buf, size,
+                                                                  [](void *data,
+                                                                     size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data !=
+                                                                          nullptr) {
+                                                                          delete static_cast<FileData *>(deleter_data);
+
+                                                                      }
+                                                                  },
+                                                                  func->data);
+
+                    auto ret = v8::Object::New(isolate);
+                    auto buffer = v8::ArrayBuffer::New(isolate, std::move(store));
+                    ret->Set(context, ConvertToV8String(isolate, "buffer"), buffer);
+                    auto mime = canvas_native_helper_get_mime(buf, size);
+                    if (mime != nullptr) {
+                        if (mime->mime_type != nullptr) {
+                            ret->Set(context, ConvertToV8String(isolate, "mime"),
+                                     ConvertToV8String(isolate, mime->mime_type));
+                        }
+                        if (mime->extension != nullptr) {
+                            ret->Set(context, ConvertToV8String(isolate, "extension"),
+                                     ConvertToV8String(isolate, mime->extension));
+                        }
+                        canvas_native_helper_release_mime(mime);
+                    }
+
+                    args[1] = ret;
+                } else {
+                    auto error = file_data->error_;
+                    args[0] = v8::Exception::Error(ConvertToV8String(isolate, error));
+                    args[1] = v8::Null(isolate);
+                    delete file_data;
+                }
+
+                v8::TryCatch tc(isolate);
+                v8::Local<v8::Value> result;
+                if (!callback->Call(context, context->Global(), 2, args).ToLocal(
+                        &result)) {
+                    if (tc.HasCaught()) {
+
+//                        v8::Local<v8::Value> stack;
+//                        bool success = tc.StackTrace(context).ToLocal(&stack);
+//                        if (!success || stack.IsEmpty()) {
+//                            if (!done) {
+//                                delete async_data;
+//                            }
+//                            return;
+//                        }
+//
+//                        v8::Local<v8::String> stackV8Str;
+//                        success = stack->ToDetailString(context).ToLocal(&stackV8Str);
+//                        if (!success || stackV8Str.IsEmpty()) {
+//                            if (!done) {
+//                                delete async_data;
+//                            }
+//                            return;
+//                        }
+
+                    }
+                }
+
+                delete async_data;
+
+            }
+        }
+    });
+
+    callback->prepare();
+
+    std::thread thread(
+            [callback, file]() {
+                bool done = false;
+                auto ret = canvas_native_helper_read_file(file.c_str());
+
+                if (!canvas_native_helper_read_file_has_error(ret)) {
+                    auto buf = canvas_native_helper_read_file_take_data(ret);
+                    callback->inner_->data = new FileData{nullptr, buf};
+                    done = true;
+                } else {
+                    auto error = canvas_native_helper_read_file_get_error(ret);
+                    callback->inner_->data = new FileData{const_cast<char *>(error), nullptr};
+                }
+                canvas_native_helper_release(ret);
+                callback->execute(done);
+            });
+
+    thread.detach();
+
+
+}
+
+
+void CanvasJSIModule::GetMime(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto file = ConvertFromV8String(isolate, args[0]);
+    auto cbFunc = args[1].As<v8::Function>();
+
 
     auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
-        if(data == nullptr){return;}
+        if (data == nullptr) { return; }
         auto async_data = static_cast<AsyncCallback *>(data);
         auto func = async_data->inner_.get();
         if (func != nullptr && func->isolate_ != nullptr) {
@@ -624,12 +752,12 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
             v8::Isolate::Scope isolate_scope(isolate);
             v8::HandleScope handle_scope(isolate);
             v8::Local<v8::Function> callback = func->callback_.Get(
-                                                                   isolate);
+                    isolate);
             v8::Local<v8::Context> context = callback->GetCreationContextChecked();
             v8::Context::Scope context_scope(context);
 
             if (func->data != nullptr) {
-                auto file_data = static_cast<FileData*>(func->data);
+                auto file_data = static_cast<FileData *>(func->data);
 
                 v8::Local<v8::Value> args[2];
 
@@ -701,11 +829,11 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                 if (!canvas_native_helper_read_file_has_error(ret)) {
                     auto buf = canvas_native_helper_read_file_take_data(ret);
-                    callback->inner_->data = new FileData {nullptr, buf};
+                    callback->inner_->data = new FileData{nullptr, buf};
                     done = true;
                 } else {
                     auto error = canvas_native_helper_read_file_get_error(ret);
-                    callback->inner_->data = new FileData {const_cast<char *>(error), nullptr};
+                    callback->inner_->data = new FileData{const_cast<char *>(error), nullptr};
                 }
                 canvas_native_helper_release(ret);
                 callback->execute(done);
@@ -714,9 +842,9 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
     thread.detach();
 
 
-
 }
 
+
 void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto options = GLOptions();
@@ -734,7 +862,7 @@ void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Valu
     auto count = args.Length();
     if (count == 6) {
         auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-        auto webgl = static_cast<WebGLState*>((void *)ctx);
+        auto webgl = (WebGLState *) ctx;
 
         auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
                                                                    new WebGLRenderingContext(
@@ -817,8 +945,8 @@ void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Val
 
     auto count = args.Length();
     if (count == 6) {
-        auto ctx = args[0].As<v8::BigInt>()->Int64Value();
-        auto webgl = static_cast<WebGLState*>((void *)ctx);
+        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
+        auto webgl = (WebGLState *) ctx;
         auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
                                                                     new WebGL2RenderingContext(
                                                                             webgl,

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

@@ -37,6 +37,8 @@ public:
 
     static void ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void GetMime(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Value> &args);