@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.21

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

@@ -32,12 +32,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPURenderBundleEncoderImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPURenderBundleEncoder);
+        SetNativeType(encoder, NativeType::GPURenderBundleEncoder);
         object->SetAlignedPointerInInternalField(0, encoder);
         encoder->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void Draw(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void DrawIndexed(const v8::FunctionCallbackInfo<v8::Value> &args);

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

@@ -22,7 +22,7 @@ void GPURenderBundleImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderBundle"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderBundle"), func).FromJust();
 }
 
 GPURenderBundleImpl *GPURenderBundleImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -47,7 +47,32 @@ v8::Local<v8::FunctionTemplate> GPURenderBundleImpl::GetCtor(v8::Isolate *isolat
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPURenderBundleTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+void
+GPURenderBundleImpl::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_render_bundle_get_label(ptr->bundle_);
+        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/GPURenderBundleImpl.h

@@ -30,12 +30,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPURenderBundleImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPURenderBundle);
+        SetNativeType(bundle, NativeType::GPURenderBundle);
         object->SetAlignedPointerInInternalField(0, bundle);
         bundle->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 
 private:
     const CanvasGPURenderBundle *bundle_;

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

@@ -28,7 +28,7 @@ void GPURenderPassEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isol
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
     canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderPassEncoder"),
-                      func).FromJust();;
+                      func).FromJust();
 }
 
 GPURenderPassEncoderImpl *
@@ -54,6 +54,11 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     tmpl->Set(
             ConvertToV8String(isolate, "beginOcclusionQuery"),
             v8::FunctionTemplate::New(isolate, &BeginOcclusionQuery));
@@ -136,6 +141,27 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
 }
 
 
+void
+GPURenderPassEncoderImpl::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_render_pass_encoder_get_label(ptr->pass_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
 void
 GPURenderPassEncoderImpl::BeginOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
@@ -229,7 +255,7 @@ void GPURenderPassEncoderImpl::DrawIndexed(const v8::FunctionCallbackInfo<v8::Va
         }
 
         auto indexCount = indexCountVal->Uint32Value(
-                                                     context).FromJust();
+                context).FromJust();
         canvas_native_webgpu_render_pass_encoder_draw_indexed(ptr->GetPass(),
                                                               indexCount,
                                                               instanceCount, firstIndex,
@@ -328,7 +354,7 @@ void GPURenderPassEncoderImpl::ExecuteBundles(const v8::FunctionCallbackInfo<v8:
         std::vector<const CanvasGPURenderBundle *> bundles;
         for (int i = 0; i < len; i++) {
             v8::Local<v8::Value> bundleVal;
-            bundlesArray->Get(context, i).ToLocal(&bundlesVal);
+            bundlesArray->Get(context, i).ToLocal(&bundleVal);
             auto type = GetNativeType(bundleVal);
             if (type == NativeType::GPURenderBundle) {
                 auto bundle = GPURenderBundleImpl::GetPointer(bundleVal.As<v8::Object>());
@@ -408,7 +434,7 @@ void GPURenderPassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::V
         auto index = indexVal->Uint32Value(context).FromJust();
         auto bindgroup = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
 
-        if (dynamicOffsets->IsUint8Array()) {
+        if (dynamicOffsets->IsUint32Array()) {
             auto buf = dynamicOffsets.As<v8::Uint32Array>();
             auto buffer = buf->Buffer();
             auto store = buffer->GetBackingStore();
@@ -446,7 +472,7 @@ void GPURenderPassEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v8:
 
     auto type = GetNativeType(bufferVal);
 
-    if (type == NativeType::GPURenderBundleEncoder) {
+    if (type == NativeType::GPUBuffer) {
         auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
         auto indexFormat = ConvertFromV8String(isolate, indexFormatVal);
         if (offsetVal->IsNumber()) {
@@ -502,7 +528,7 @@ void GPURenderPassEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::Va
     }
 
     auto pipelineVal = args[0];
-    if(GetNativeType(pipelineVal) == NativeType::GPURenderPipeline){
+    if (GetNativeType(pipelineVal) == NativeType::GPURenderPipeline) {
         auto pipeline = GPURenderPipelineImpl::GetPointer(pipelineVal.As<v8::Object>());
         canvas_native_webgpu_render_pass_encoder_set_pipeline(ptr->GetPass(),
                                                               pipeline->GetGPUPipeline());
@@ -565,13 +591,13 @@ void GPURenderPassEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8
     int64_t size = -1;
     auto offsetVal = args[2];
     auto sizeVal = args[3];
-
-    if (slotVal->IsUint32() && bufferVal->IsObject()) {
-        auto slot = slotVal.As<v8::Uint32>()->Value();
-        if (GetNativeType(bufferVal) != NativeType::GPUBuffer) {
-            // todo throw ??
-            return;
-        }
+    auto type = GetNativeType(bufferVal);
+    auto isolate = args.GetIsolate();
+    if (type == NativeType::GPUBuffer) {
+        auto context = isolate->GetCurrentContext();
+        auto slot = slotVal->ToUint32(context).ToLocalChecked();
+        
+    
 
         auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
 
@@ -583,7 +609,7 @@ void GPURenderPassEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8
             size = (int64_t) sizeVal.As<v8::Number>()->Value();
         }
 
-        canvas_native_webgpu_render_pass_encoder_set_vertex_buffer(ptr->GetPass(), slot,
+        canvas_native_webgpu_render_pass_encoder_set_vertex_buffer(ptr->GetPass(), slot->Value(),
                                                                    buffer->GetGPUBuffer(), offset,
                                                                    size);
 

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

@@ -32,12 +32,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPURenderPassEncoderImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPURenderPassEncoder);
+        SetNativeType(encoder, NativeType::GPURenderPassEncoder);
         object->SetAlignedPointerInInternalField(0, encoder);
         encoder->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void BeginOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void Draw(const v8::FunctionCallbackInfo<v8::Value> &args);

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

@@ -23,7 +23,7 @@ void GPURenderPipelineImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderPipeline"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderPipeline"), func).FromJust();
 }
 
 GPURenderPipelineImpl *GPURenderPipelineImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -48,6 +48,10 @@ v8::Local<v8::FunctionTemplate> GPURenderPipelineImpl::GetCtor(v8::Isolate *isol
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     tmpl->Set(
             ConvertToV8String(isolate, "getBindGroupLayout"),
@@ -82,3 +86,24 @@ void GPURenderPipelineImpl::GetBindGroupLayout(const v8::FunctionCallbackInfo<v8
     args.GetReturnValue().SetUndefined();
 }
 
+
+void
+GPURenderPipelineImpl::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_render_pipeline_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/GPURenderPipelineImpl.h

@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPURenderPipelineImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPURenderPipeline);
+        SetNativeType(pipeline, NativeType::GPURenderPipeline);
         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);
+
 
     static void GetBindGroupLayout(const v8::FunctionCallbackInfo <v8::Value> &args);
 

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

@@ -22,7 +22,7 @@ void GPUSamplerImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isola
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSampler"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSampler"), func).FromJust();
 }
 
 GPUSamplerImpl *GPUSamplerImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -47,7 +47,33 @@ v8::Local<v8::FunctionTemplate> GPUSamplerImpl::GetCtor(v8::Isolate *isolate) {
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPUSamplerTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUSamplerImpl::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_sampler_get_label(ptr->sampler_);
+        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/GPUSamplerImpl.h

@@ -9,7 +9,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class GPUSamplerImpl: ObjectWrapperImpl {
+class GPUSamplerImpl : ObjectWrapperImpl {
 public:
     explicit GPUSamplerImpl(const CanvasGPUSampler *sampler);
 
@@ -30,12 +30,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUSamplerImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUSampler);
+        SetNativeType(sampler, NativeType::GPUSampler);
         object->SetAlignedPointerInInternalField(0, sampler);
         sampler->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 
 private:
     const CanvasGPUSampler *sampler_;

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

@@ -22,7 +22,7 @@ void GPUShaderModuleImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUShaderModule"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUShaderModule"), func).FromJust();
 }
 
 GPUShaderModuleImpl *GPUShaderModuleImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -47,10 +47,34 @@ v8::Local<v8::FunctionTemplate> GPUShaderModuleImpl::GetCtor(v8::Isolate *isolat
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     cache->GPUShaderModuleTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
+void
+GPUShaderModuleImpl::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_shader_module_get_label(ptr->shaderModule_);
+        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/GPUShaderModuleImpl.h

@@ -11,7 +11,7 @@
 
 class GPUShaderModuleImpl : ObjectWrapperImpl {
 public:
-    GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
+    explicit GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
 
     ~GPUShaderModuleImpl() {
         canvas_native_webgpu_shader_module_release(this->GetShaderModule());
@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUShaderModuleImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUShaderModule);
+        SetNativeType(shaderModule, NativeType::GPUShaderModule);
         object->SetAlignedPointerInInternalField(0, shaderModule);
         shaderModule->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 private:
     const CanvasGPUShaderModule *shaderModule_;
 };

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

@@ -22,7 +22,7 @@ void GPUSupportedLimitsImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSupportedLimits"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSupportedLimits"), func).FromJust();
 }
 
 GPUSupportedLimitsImpl *GPUSupportedLimitsImpl::GetPointer(v8::Local<v8::Object> object) {
@@ -281,7 +281,7 @@ void GPUSupportedLimitsImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &arg
 
     ret->SetAlignedPointerInInternalField(0, object);
 
-    SetNativeType(ret, NativeType::GPUSupportedLimits);
+    SetNativeType(object, NativeType::GPUSupportedLimits);
 
     object->BindFinalizer(isolate, ret);
 

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

@@ -10,7 +10,7 @@
 
 class GPUSupportedLimitsImpl : public ObjectWrapperImpl {
 public:
-    GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits);
+    explicit GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits);
 
     ~GPUSupportedLimitsImpl() {
         canvas_native_webgpu_limits_release(this->limits_);
@@ -23,7 +23,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUSupportedLimitsImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUSupportedLimits);
+        SetNativeType(limits, NativeType::GPUSupportedLimits);
         object->SetAlignedPointerInInternalField(0, limits);
         limits->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -5,6 +5,7 @@
 #include "GPUTextureImpl.h"
 #include "Caches.h"
 #include "GPUTextureViewImpl.h"
+#include "GPULabel.h"
 
 GPUTextureImpl::GPUTextureImpl(const CanvasGPUTexture *texture) : texture_(texture) {}
 
@@ -47,6 +48,10 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     tmpl->Set(
             ConvertToV8String(isolate, "destroy"),
@@ -107,6 +112,27 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
     return ctorTmpl;
 }
 
+
+void
+GPUTextureImpl::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_texture_get_label(ptr->texture_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
 void
 GPUTextureImpl::GetDimension(v8::Local<v8::Name> name,
                              const v8::PropertyCallbackInfo<v8::Value> &info) {
@@ -249,6 +275,7 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
             aspect, 0, -1, 0, -1
     };
 
+    GPULabel label;
 
     if (descVal->IsObject()) {
         descriptor = new CanvasCreateTextureViewDescriptor{};
@@ -269,7 +296,6 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         }
 
 
-
         v8::Local<v8::Value> arrayLayerCountVal;
         if (descObj->Get(context, ConvertToV8String(isolate, "arrayLayerCount")).ToLocal(
                 &arrayLayerCountVal) && arrayLayerCountVal->IsInt32()) {
@@ -297,16 +323,15 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         descriptor->range = &range;
 
 
-
         v8::Local<v8::Value> formatVal;
         descObj->Get(context, ConvertToV8String(isolate, "format")).ToLocal(&formatVal);
         auto formatStr = ConvertFromV8String(isolate, formatVal);
 
-        descriptor->format = CanvasOptionalGPUTextureFormat {
-           CanvasOptionalGPUTextureFormatNone
+        descriptor->format = CanvasOptionalGPUTextureFormat{
+                CanvasOptionalGPUTextureFormatNone
         };
 
-        if (!formatStr.empty()){
+        if (!formatStr.empty()) {
             auto format = canvas_native_webgpu_enum_string_to_gpu_texture(formatStr.c_str());
             descriptor->format = format;
         }
@@ -317,9 +342,9 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         v8::Local<v8::Value> labelVal;
         descObj->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
 
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            descriptor->label = *v8::String::Utf8Value(isolate, labelVal);
-        }
+        label = GPULabel(isolate, labelVal);
+
+        descriptor->label = *label;
 
         v8::Local<v8::Value> dimensionVal;
         if (descObj->Get(context, ConvertToV8String(isolate, "dimension")).ToLocal(&dimensionVal)) {
@@ -347,6 +372,7 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     if (descriptor != nullptr) {
         delete descriptor;
+        descriptor = nullptr;
     }
 
     if (view != nullptr) {

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

@@ -25,17 +25,19 @@ public:
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUTextureImpl *queue) {
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUTextureImpl *texture) {
         auto context = isolate->GetCurrentContext();
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUTextureImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUTexture);
-        object->SetAlignedPointerInInternalField(0, queue);
-        queue->BindFinalizer(isolate, object);
+        SetNativeType(texture, NativeType::GPUTexture);
+        object->SetAlignedPointerInInternalField(0, texture);
+        texture->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
 
     static void GetWidth(v8::Local<v8::Name> name,

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

@@ -21,7 +21,7 @@ void GPUTextureViewImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *i
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUTextureView"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUTextureView"), func).FromJust();
 }
 
 GPUTextureViewImpl *GPUTextureViewImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -46,8 +46,34 @@ v8::Local<v8::FunctionTemplate> GPUTextureViewImpl::GetCtor(v8::Isolate *isolate
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
 
     cache->GPUTextureViewTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUTextureViewImpl::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_texture_view_get_label(ptr->view_);
+        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/GPUTextureViewImpl.h

@@ -11,7 +11,7 @@
 
 class GPUTextureViewImpl : ObjectWrapperImpl {
 public:
-    GPUTextureViewImpl(const CanvasGPUTextureView *view);
+    explicit GPUTextureViewImpl(const CanvasGPUTextureView *view);
 
     ~GPUTextureViewImpl() {
         canvas_native_webgpu_texture_view_release(this->GetTextureView());
@@ -30,12 +30,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUTextureViewImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUTextureView);
+        SetNativeType(view, NativeType::GPUTextureView);
         object->SetAlignedPointerInInternalField(0, view);
         view->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 
 private:
     const CanvasGPUTextureView *view_;