@nativescript/canvas 2.0.0-beta.9 → 2.0.0-rc.0

package/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h

@@ -0,0 +1,97 @@
+//
+// Created by Osei Fortune on 18/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUDEVICEIMPL_H
+#define CANVAS_ANDROID_GPUDEVICEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUDeviceImpl : ObjectWrapperImpl {
+public:
+    explicit GPUDeviceImpl(const CanvasGPUDevice *device);
+
+    ~GPUDeviceImpl() {
+        canvas_native_webgpu_device_release(this->device_);
+    }
+
+    const CanvasGPUDevice *GetGPUDevice();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUDeviceImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUDeviceImpl *device) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUDeviceImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(device, NativeType::GPUDevice);
+        object->SetAlignedPointerInInternalField(0, device);
+        device->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetFeatures(v8::Local<v8::Name> name,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLimits(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetQueue(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLost(v8::Local<v8::Name> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateBindGroupLayout(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateCommandEncoder(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateComputePipeline(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateComputePipelineAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreatePipelineLayout(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateQuerySet(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderBundleEncoder(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderPipelineAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateShaderModule(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PopErrorScope(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PushErrorScope(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void SetUncapturedError(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    const CanvasGPUDevice *device_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUDEVICEIMPL_H

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

@@ -0,0 +1,200 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#include "GPUImpl.h"
+#include "Caches.h"
+
+GPUImpl::GPUImpl(const CanvasWebGPUInstance *instance) : instance_(instance) {}
+
+const CanvasWebGPUInstance *GPUImpl::GetGPUInstance() {
+    return this->instance_;
+}
+
+void GPUImpl::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, "GPU"), func).FromJust();
+}
+
+
+GPUImpl *GPUImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUTmpl.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, "GPU"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(ConvertToV8String(isolate, "__getPointer"),
+              v8::FunctionTemplate::New(isolate, __GetPointer));
+
+    tmpl->Set(ConvertToV8String(isolate, "requestAdapter"),
+              v8::FunctionTemplate::New(isolate, &RequestAdapter));
+
+    cache->GPUTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void GPUImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+
+    auto ret = args.This();
+
+    auto instance = canvas_native_webgpu_instance_create();
+
+    auto object = new GPUImpl(instance);
+
+    ret->SetAlignedPointerInInternalField(0, object);
+
+    SetNativeType(object, NativeType::GPUInstance);
+
+    object->BindFinalizer(isolate, ret);
+
+    args.GetReturnValue().Set(ret);
+}
+
+
+void GPUImpl::RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    GPUImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args[1].As<v8::Function>()->Call(context, context->Global(), 0, nullptr);
+        return;
+    }
+
+
+    CanvasGPURequestAdapterOptions opts{};
+    opts.force_fallback_adapter = false;
+    opts.power_preference = CanvasGPUPowerPreference::CanvasGPUPowerPreferenceNone;
+    auto optionsValue = args[0];
+
+    if (optionsValue->IsObject()) {
+        auto options = optionsValue.As<v8::Object>();
+        v8::Local<v8::Value> ppValue;
+        options->Get(context, ConvertToV8String(isolate, "powerPreference")).ToLocal(&ppValue);
+        if (ppValue->IsNumber()) {
+            switch (ppValue->Int32Value(context).ToChecked()) {
+                case 1:
+                    opts.power_preference = CanvasGPUPowerPreference::CanvasGPUPowerPreferenceLowPower;
+                    break;
+                case 2:
+                    opts.power_preference = CanvasGPUPowerPreference::CanvasGPUPowerPreferenceHighPerformance;
+                    break;
+                default:
+                    break;
+            }
+
+        }
+
+        v8::Local<v8::Value> forceFallbackValue;
+
+        options->Get(context, ConvertToV8String(isolate, "forceFallbackAdapter")).ToLocal(
+                &forceFallbackValue);
+
+
+        if (!forceFallbackValue.IsEmpty()) {
+            opts.force_fallback_adapter = forceFallbackValue->BooleanValue(isolate);
+        }
+    }
+
+
+    auto callback = new AsyncCallback{
+            isolate,
+            args[1].As<v8::Function>(),
+            [](bool done, void *data) {
+                if (data != nullptr) {
+                    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 impl = new GPUAdapterImpl(
+                                    static_cast<const CanvasGPUAdapter *>(func->data));
+                            auto ret = GPUAdapterImpl::NewInstance(
+                                    isolate, impl);
+
+
+                            v8::Local<v8::Value> args[2] = {
+                                    v8::Null(isolate), ret};
+
+
+                            callback->Call(context, context->Global(),
+                                           2,
+                                           args);  // ignore JS return value
+                            
+                            delete static_cast<AsyncCallback *>(data);
+
+                        } else {
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Null(isolate)};
+
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                            delete static_cast<AsyncCallback *>(data);
+                        }
+                    }
+                }
+            }
+    };
+    callback->prepare();
+    canvas_native_webgpu_request_adapter(ptr->GetGPUInstance(), &opts,
+                                         [](const CanvasGPUAdapter *adapter, void *data) {
+                                             if (data != nullptr) {
+                                                 auto async_data = static_cast<AsyncCallback *>(data);
+                                                 auto inner = async_data->inner_.get();
+                                                 if (inner != nullptr) {
+                                                     inner->data = (void *) adapter;
+                                                     async_data->execute(true);
+                                                 }
+                                             }
+                                         }, callback);
+}
+
+
+void GPUImpl::__GetPointer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto pointer = canvas_native_webgpu_get_pointer_addr(ptr->GetGPUInstance());
+    auto ret = std::to_string(pointer);
+    args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+}

package/platforms/ios/src/cpp/webgpu/GPUImpl.h

@@ -0,0 +1,55 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUIMPL_H
+#define CANVAS_ANDROID_GPUIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "GPUAdapterImpl.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUImpl : ObjectWrapperImpl {
+public:
+    explicit GPUImpl(const CanvasWebGPUInstance *instance);
+
+    ~GPUImpl() {
+        if (this->instance_ != nullptr) {
+            canvas_native_webgpu_instance_release(this->instance_);
+            this->instance_ = nullptr;
+        }
+    }
+
+    const CanvasWebGPUInstance *GetGPUInstance();
+
+    static void Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate);
+
+    static GPUImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUImpl *instance) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(instance, NativeType::GPUInstance);
+        object->SetAlignedPointerInInternalField(0, instance);
+        instance->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void __GetPointer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+private:
+    const CanvasWebGPUInstance *instance_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUIMPL_H

package/platforms/ios/src/cpp/webgpu/GPULabel.h

@@ -0,0 +1,33 @@
+//
+// Created by Osei Fortune on 19/08/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPULABEL_H
+#define CANVAS_ANDROID_GPULABEL_H
+
+#include "Common.h"
+#include "Helpers.h"
+
+class GPULabel {
+public:
+    GPULabel(){}
+    GPULabel(v8::Isolate *isolate, const v8::Local<v8::Value> &label) {
+        if (label->IsString() || label->IsStringObject()) {
+            label_ = ConvertFromV8String(isolate, label);
+            hasLabel_ = true;
+        }
+    }
+
+    const char *operator*() {
+        if (hasLabel_) {
+            return label_.c_str();
+        }
+        return nullptr;
+    }
+
+private:
+    std::string label_;
+    bool hasLabel_ = false;
+};
+
+#endif //CANVAS_ANDROID_GPULABEL_H

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

@@ -0,0 +1,80 @@
+//
+// Created by Osei Fortune on 26/06/2024.
+//
+
+#include "GPUPipelineLayoutImpl.h"
+#include "Caches.h"
+
+GPUPipelineLayoutImpl::GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline) : pipeline_(
+        pipeline) {}
+
+const CanvasGPUPipelineLayout *GPUPipelineLayoutImpl::GetPipeline() {
+    return this->pipeline_;
+}
+
+
+void GPUPipelineLayoutImpl::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, "GPUPipelineLayout"), func).FromJust();
+}
+
+GPUPipelineLayoutImpl *GPUPipelineLayoutImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUPipelineLayoutImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUPipelineLayoutImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUPipelineLayoutTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUPipelineLayout"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+    cache->GPUPipelineLayoutTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUPipelineLayoutImpl::GetLabel(v8::Local<v8::Name> name,
+                                const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_pipeline_layout_get_label(ptr->pipeline_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+

package/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.h

@@ -0,0 +1,49 @@
+//
+// Created by Osei Fortune on 26/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUPIPELINELAYOUTIMPL_H
+#define CANVAS_ANDROID_GPUPIPELINELAYOUTIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+
+class GPUPipelineLayoutImpl : ObjectWrapperImpl {
+public:
+    explicit GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline);
+
+    ~GPUPipelineLayoutImpl() {
+        canvas_native_webgpu_pipeline_layout_release(this->GetPipeline());
+    }
+
+    const CanvasGPUPipelineLayout *GetPipeline();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUPipelineLayoutImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, GPUPipelineLayoutImpl *pipeline) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUPipelineLayoutImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(pipeline, NativeType::GPUPipelineLayout);
+        object->SetAlignedPointerInInternalField(0, pipeline);
+        pipeline->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+private:
+    const CanvasGPUPipelineLayout *pipeline_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUPIPELINELAYOUTIMPL_H

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

@@ -0,0 +1,136 @@
+//
+// Created by Osei Fortune on 23/06/2024.
+//
+
+#include "GPUQuerySetImpl.h"
+#include "Caches.h"
+
+GPUQuerySetImpl::GPUQuerySetImpl(const CanvasGPUQuerySet *querySet) : querySet_(querySet) {}
+
+const CanvasGPUQuerySet *GPUQuerySetImpl::GetQuerySet() {
+    return this->querySet_;
+}
+
+
+void GPUQuerySetImpl::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, "GPUQuerySet"), func).FromJust();
+}
+
+GPUQuerySetImpl *GPUQuerySetImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUQuerySetImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUQuerySetImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUQuerySetTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUQuerySet"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "count"),
+            GetCount
+    );
+
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "type"),
+            GetType
+    );
+
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
+
+    cache->GPUQuerySetTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void
+GPUQuerySetImpl::GetCount(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        info.GetReturnValue().Set(canvas_native_webgpu_query_set_get_count(ptr->GetQuerySet()));
+        return;
+    }
+
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+GPUQuerySetImpl::GetType(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        auto type = canvas_native_webgpu_query_set_get_type(ptr->GetQuerySet());
+        switch (type) {
+            case CanvasQueryTypeOcclusion:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "occlusion"));
+                break;
+            case CanvasQueryTypeTimestamp:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "timestamp"));
+                break;
+        }
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+GPUQuerySetImpl::GetLabel(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_query_set_get_label(ptr->GetQuerySet());
+        if (label != nullptr) {
+            info.GetReturnValue().Set(ConvertToV8String(isolate, label));
+            canvas_native_string_destroy(label);
+            return;
+        }
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
+void GPUQuerySetImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    canvas_native_webgpu_query_set_destroy(ptr->querySet_);
+
+}