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

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

@@ -0,0 +1,88 @@
+//
+// Created by Osei Fortune on 14/06/2025.
+//
+
+#include "GPUCompilationInfoImpl.h"
+#include "Caches.h"
+#include "GPUCompilationMessageImpl.h"
+
+GPUCompilationInfoImpl::GPUCompilationInfoImpl(CanvasGPUCompilationInfo *info) : info_(
+        info) {}
+
+CanvasGPUCompilationInfo *GPUCompilationInfoImpl::GetCompilationInfo() {
+    return this->info_;
+}
+
+
+void GPUCompilationInfoImpl::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, "GPUCompilationInfo"), func).FromJust();
+}
+
+GPUCompilationInfoImpl *GPUCompilationInfoImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUCompilationInfoImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUCompilationInfoImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUCompilationInfoTmpl.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, "GPUCompilationInfo"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "messages"),
+            GetMessages
+    );
+
+
+    cache->GPUCompilationInfoTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUCompilationInfoImpl::GetMessages(v8::Local<v8::Name> name,
+                                    const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto isolate = info.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto count = canvas_native_webgpu_compilation_info_get_messages_count(
+                ptr->GetCompilationInfo());
+        auto array = v8::Array::New(isolate, (int) count);
+        for (int i = 0; i < count; i++) {
+            auto msg = canvas_native_webgpu_compilation_info_get_message_at(
+                    ptr->GetCompilationInfo(), i);
+            if (msg != nullptr) {
+                auto ret = new GPUCompilationMessageImpl(msg);
+                array->Set(context, i, GPUCompilationMessageImpl::NewInstance(isolate, ret));
+            }
+        }
+
+        info.GetReturnValue().Set(array);
+
+        return;
+    }
+
+    info.GetReturnValue().Set(v8::Array::New(isolate));
+}

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

@@ -0,0 +1,49 @@
+//
+// Created by Osei Fortune on 14/06/2025.
+//
+
+#ifndef CANVAS_ANDROID_GPUCOMPILATIONINFOIMPL_H
+#define CANVAS_ANDROID_GPUCOMPILATIONINFOIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUCompilationInfoImpl : ObjectWrapperImpl {
+public:
+    explicit GPUCompilationInfoImpl(CanvasGPUCompilationInfo *info);
+
+    ~GPUCompilationInfoImpl() {
+        canvas_native_webgpu_compilation_info_release(this->GetCompilationInfo());
+    }
+
+    CanvasGPUCompilationInfo* GetCompilationInfo();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUCompilationInfoImpl *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, GPUCompilationInfoImpl *info) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUCompilationInfoImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(info, NativeType::GPUCompilationInfo);
+        object->SetAlignedPointerInInternalField(0, info);
+        info->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetMessages(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+private:
+    CanvasGPUCompilationInfo *info_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUCOMPILATIONINFOIMPL_H

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

@@ -0,0 +1,193 @@
+//
+// Created by Osei Fortune on 14/06/2025.
+//
+
+#include "GPUCompilationMessageImpl.h"
+#include "Caches.h"
+
+GPUCompilationMessageImpl::GPUCompilationMessageImpl(CanvasGPUCompilationMessage *message)
+        : message_(
+        message) {}
+
+CanvasGPUCompilationMessage *GPUCompilationMessageImpl::GetMessage() {
+    return this->message_;
+}
+
+
+void GPUCompilationMessageImpl::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, "GPUCompilationMessage"),
+                      func).FromJust();
+}
+
+GPUCompilationMessageImpl *
+GPUCompilationMessageImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUCompilationMessageImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUCompilationMessageImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUCompilationMessageTmpl.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, "GPUCompilationMessage"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "length"),
+            GetLength
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "lineNum"),
+            GetLineNum
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "linePos"),
+            GetLinePos
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "message"),
+            GetMessage
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "offset"),
+            GetOffset
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "type"),
+            GetType
+    );
+
+    cache->GPUCompilationMessageTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void
+GPUCompilationMessageImpl::GetLength(v8::Local<v8::Name> name,
+                                     const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto len = canvas_native_webgpu_compilation_message_get_length(ptr->GetMessage());
+
+        info.GetReturnValue().Set((double) len);
+
+        return;
+    }
+
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+GPUCompilationMessageImpl::GetLineNum(v8::Local<v8::Name> name,
+                                      const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto num = canvas_native_webgpu_compilation_message_get_line_num(ptr->GetMessage());
+
+        info.GetReturnValue().Set((double) num);
+
+        return;
+    }
+
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+GPUCompilationMessageImpl::GetLinePos(v8::Local<v8::Name> name,
+                                      const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto pos = canvas_native_webgpu_compilation_message_get_line_pos(ptr->GetMessage());
+
+        info.GetReturnValue().Set((double) pos);
+
+        return;
+    }
+
+    info.GetReturnValue().Set(0);
+}
+
+void
+GPUCompilationMessageImpl::GetMessage(v8::Local<v8::Name> name,
+                                      const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto len = canvas_native_webgpu_compilation_message_get_message(ptr->GetMessage());
+
+        info.GetReturnValue().Set(ConvertToV8String(isolate, len));
+
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
+void
+GPUCompilationMessageImpl::GetOffset(v8::Local<v8::Name> name,
+                                     const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto offset = canvas_native_webgpu_compilation_message_get_offset(ptr->GetMessage());
+
+        info.GetReturnValue().Set((double) offset);
+
+        return;
+    }
+
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+GPUCompilationMessageImpl::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 message_type = canvas_native_webgpu_compilation_message_get_type(ptr->GetMessage());
+
+        switch (message_type) {
+            case CanvasGPUCompilationMessageType::CanvasGPUCompilationMessageTypeInfo:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "info"));
+                break;
+            case CanvasGPUCompilationMessageType::CanvasGPUCompilationMessageTypeWarning:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "warning"));
+                break;
+            case CanvasGPUCompilationMessageType::CanvasGPUCompilationMessageTypeError:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "error"));
+                break;
+
+        }
+
+        return;
+    }
+
+    info.GetReturnValue().Set(ConvertToV8String(isolate, "error"));
+}

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

@@ -0,0 +1,64 @@
+//
+// Created by Osei Fortune on 14/06/2025.
+//
+
+#ifndef CANVAS_ANDROID_GPUCOMPILATIONMESSAGEIMPL_H
+#define CANVAS_ANDROID_GPUCOMPILATIONMESSAGEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUCompilationMessageImpl : ObjectWrapperImpl {
+public:
+    explicit GPUCompilationMessageImpl(CanvasGPUCompilationMessage *message);
+
+    ~GPUCompilationMessageImpl() {
+        canvas_native_webgpu_compilation_message_release(this->GetMessage());
+    }
+
+    CanvasGPUCompilationMessage *GetMessage();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUCompilationMessageImpl *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, GPUCompilationMessageImpl *message) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUCompilationMessageImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(message, NativeType::GPUCompilationMessage);
+        object->SetAlignedPointerInInternalField(0, message);
+        message->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetLength(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLineNum(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLinePos(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetMessage(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetOffset(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetType(v8::Local<v8::Name> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+private:
+    CanvasGPUCompilationMessage *message_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUCOMPILATIONMESSAGEIMPL_H

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

@@ -1295,7 +1295,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
     auto options = optionsVal.As<v8::Object>();
 
     v8::Local<v8::Value> stencilValue;
-    auto hasDepthStencil = options->Get(context, ConvertToV8String(isolate, "depthStencil")).ToLocal(
+    auto hasDepthStencil = options->Get(context,
+                                        ConvertToV8String(isolate, "depthStencil")).ToLocal(
             &stencilValue);
 
     CanvasDepthStencilState *stencil = nullptr;
@@ -1533,7 +1534,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
             v8::Local<v8::Value> writeMaskVal;
 
-            auto hasWriteMask = state->Get(context, ConvertToV8String(isolate, "writeMask")).ToLocal(&writeMaskVal);
+            auto hasWriteMask = state->Get(context,
+                                           ConvertToV8String(isolate, "writeMask")).ToLocal(
+                    &writeMaskVal);
 
             if (hasWriteMask && writeMaskVal->IsUint32()) {
                 writeMask = writeMaskVal->Uint32Value(context).FromJust();
@@ -1545,7 +1548,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
             v8::Local<v8::Value> blendVal;
 
-            auto hasBlend = state->Get(context, ConvertToV8String(isolate, "blend")).ToLocal(&blendVal);
+            auto hasBlend = state->Get(context, ConvertToV8String(isolate, "blend")).ToLocal(
+                    &blendVal);
 
             if (hasBlend && blendVal->IsObject()) {
                 auto blendObj = blendVal.As<v8::Object>();
@@ -1639,7 +1643,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
         v8::Local<v8::Value> constantsVal;
-        auto hasConstants = fragmentValueObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(
+        auto hasConstants = fragmentValueObj->Get(context,
+                                                  ConvertToV8String(isolate, "constants")).ToLocal(
                 &constantsVal);
 
         if (hasConstants && constantsVal->IsMap()) {
@@ -1676,7 +1681,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
         v8::Local<v8::Value> entryPoint;
-        auto hasEntryPoint = fragmentValueObj->Get(context, ConvertToV8String(isolate, "entryPoint")).ToLocal(
+        auto hasEntryPoint = fragmentValueObj->Get(context, ConvertToV8String(isolate,
+                                                                              "entryPoint")).ToLocal(
                 &entryPoint);
 
 
@@ -1755,7 +1761,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         v8::Local<v8::Value> count;
         v8::Local<v8::Value> mask;
 
-        auto hasAlphaToCoverageEnabled = multisampleObj->Get(context, ConvertToV8String(isolate, "alphaToCoverageEnabled")).
+        auto hasAlphaToCoverageEnabled = multisampleObj->Get(context, ConvertToV8String(isolate,
+                                                                                        "alphaToCoverageEnabled")).
                 ToLocal(&alphaToCoverageEnabled);
 
         if (hasAlphaToCoverageEnabled && alphaToCoverageEnabled->IsBoolean()) {
@@ -1802,7 +1809,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
                 CanvasOptionalIndexFormatNone
         };
 
-        primitive->topology = CanvasPrimitiveTopologyTriangleList;
+        primitive->topology = CanvasOptionalPrimitiveTopology{
+                CanvasOptionalPrimitiveTopologyNone
+        };
 
         primitive->unclipped_depth = false;
 
@@ -1919,19 +1928,24 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
                 auto topology = topologyValue.As<v8::Uint32>()->Value();
                 switch (topology) {
                     case 0:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
                         break;
                     case 1:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
                         break;
                     case 2:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
                         break;
                     case 3:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
                         break;
                     case 4:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
                         break;
                     default:
                         break;
@@ -1939,15 +1953,20 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
             } else if (topologyValue->IsString()) {
                 auto topology = ConvertFromV8String(isolate, topologyValue);
                 if (topology == "line-list") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
                 } else if (topology == "line-strip") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
                 } else if (topology == "point-list") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
                 } else if (topology == "triangle-list") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
                 } else if (topology == "triangle-strip") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
                 }
             }
 
@@ -1968,7 +1987,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> vertexValue;
-   auto hasVertex = options->Get(context, ConvertToV8String(isolate, "vertex")).ToLocal(
+    auto hasVertex = options->Get(context, ConvertToV8String(isolate, "vertex")).ToLocal(
             &vertexValue);
 
 
@@ -1990,7 +2009,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         vertex->module = module->GetShaderModule();
 
         v8::Local<v8::Value> constantsVal;
-        auto hasConstants = vertexObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(&constantsVal);
+        auto hasConstants = vertexObj->Get(context,
+                                           ConvertToV8String(isolate, "constants")).ToLocal(
+                &constantsVal);
 
         if (hasConstants && constantsVal->IsMap()) {
             auto constants = constantsVal.As<v8::Map>();
@@ -2027,7 +2048,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
         v8::Local<v8::Value> buffersVal;
-        auto hasBuffers = vertexObj->Get(context, ConvertToV8String(isolate, "buffers")).ToLocal(&buffersVal);
+        auto hasBuffers = vertexObj->Get(context, ConvertToV8String(isolate, "buffers")).ToLocal(
+                &buffersVal);
 
         uint64_t stride = 0;
         if (hasBuffers && buffersVal->IsArray()) {
@@ -2039,7 +2061,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
                 v8::Local<v8::Value> arrayStride;
 
-                auto hasArrayStride = buffer->Get(context, ConvertToV8String(isolate, "arrayStride")).ToLocal(
+                auto hasArrayStride = buffer->Get(context, ConvertToV8String(isolate,
+                                                                             "arrayStride")).ToLocal(
                         &arrayStride);
 
                 if (hasArrayStride && arrayStride->IsNumber()) {
@@ -2050,7 +2073,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
                 v8::Local<v8::Value> attributesValue;
 
-                auto hasAttributes = buffer->Get(context, ConvertToV8String(isolate, "attributes")).ToLocal(
+                auto hasAttributes = buffer->Get(context,
+                                                 ConvertToV8String(isolate, "attributes")).ToLocal(
                         &attributesValue);
 
                 if (hasAttributes && attributesValue->IsArray()) {
@@ -2629,7 +2653,6 @@ void GPUDeviceImpl::CreateRenderPipelineAsync(const v8::FunctionCallbackInfo<v8:
     descriptor.label = *label;
 
 
-
     v8::Local<v8::Value> layoutVal;
     options->Get(context, ConvertToV8String(isolate, "layout")).ToLocal(
             &layoutVal);
@@ -2721,7 +2744,9 @@ void GPUDeviceImpl::CreateRenderPipelineAsync(const v8::FunctionCallbackInfo<v8:
                 CanvasOptionalIndexFormatNone
         };
 
-        primitive->topology = CanvasPrimitiveTopologyTriangleList;
+        primitive->topology = CanvasOptionalPrimitiveTopology{
+                CanvasOptionalPrimitiveTopologyNone
+        };
 
         primitive->unclipped_depth = false;
 
@@ -2838,19 +2863,24 @@ void GPUDeviceImpl::CreateRenderPipelineAsync(const v8::FunctionCallbackInfo<v8:
                 auto topology = topologyValue.As<v8::Uint32>()->Value();
                 switch (topology) {
                     case 0:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
                         break;
                     case 1:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
                         break;
                     case 2:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
                         break;
                     case 3:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
                         break;
                     case 4:
-                        primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
+                        primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                        primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
                         break;
                     default:
                         break;
@@ -2858,15 +2888,20 @@ void GPUDeviceImpl::CreateRenderPipelineAsync(const v8::FunctionCallbackInfo<v8:
             } else if (topologyValue->IsString()) {
                 auto topology = ConvertFromV8String(isolate, topologyValue);
                 if (topology == "line-list") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineList;
                 } else if (topology == "line-strip") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyLineStrip;
                 } else if (topology == "point-list") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyPointList;
                 } else if (topology == "triangle-list") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleList;
                 } else if (topology == "triangle-strip") {
-                    primitive->topology = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
+                    primitive->topology.tag = CanvasOptionalPrimitiveTopologySome;
+                    primitive->topology.some = CanvasPrimitiveTopology::CanvasPrimitiveTopologyTriangleStrip;
                 }
             }