@shopify/react-native-skia 2.4.15 → 2.4.17

package/cpp/rnwgpu/api/descriptors/GPUBindGroupLayoutDescriptor.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "GPUBindGroupLayoutEntry.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupLayoutDescriptor {
+  std::vector<std::shared_ptr<GPUBindGroupLayoutEntry>>
+      entries;                      // Iterable<GPUBindGroupLayoutEntry>
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "entries")) {
+        auto prop = value.getProperty(runtime, "entries");
+        result->entries = JSIConverter<std::vector<
+            std::shared_ptr<GPUBindGroupLayoutEntry>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupLayoutDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupLayoutEntry.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "GPUBufferBindingLayout.h"
+#include "GPUExternalTextureBindingLayout.h"
+#include "GPUSamplerBindingLayout.h"
+#include "GPUStorageTextureBindingLayout.h"
+#include "GPUTextureBindingLayout.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupLayoutEntry {
+  double binding;    // GPUIndex32
+  double visibility; // GPUShaderStageFlags
+  std::optional<std::shared_ptr<GPUBufferBindingLayout>>
+      buffer; // GPUBufferBindingLayout
+  std::optional<std::shared_ptr<GPUSamplerBindingLayout>>
+      sampler; // GPUSamplerBindingLayout
+  std::optional<std::shared_ptr<GPUTextureBindingLayout>>
+      texture; // GPUTextureBindingLayout
+  std::optional<std::shared_ptr<GPUStorageTextureBindingLayout>>
+      storageTexture; // GPUStorageTextureBindingLayout
+  std::optional<std::shared_ptr<GPUExternalTextureBindingLayout>>
+      externalTexture; // GPUExternalTextureBindingLayout
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutEntry>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "binding")) {
+        auto prop = value.getProperty(runtime, "binding");
+        result->binding = JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "visibility")) {
+        auto prop = value.getProperty(runtime, "visibility");
+        result->visibility =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "buffer")) {
+        auto prop = value.getProperty(runtime, "buffer");
+        result->buffer = JSIConverter<std::optional<
+            std::shared_ptr<GPUBufferBindingLayout>>>::fromJSI(runtime, prop,
+                                                               false);
+      }
+      if (value.hasProperty(runtime, "sampler")) {
+        auto prop = value.getProperty(runtime, "sampler");
+        result->sampler = JSIConverter<std::optional<
+            std::shared_ptr<GPUSamplerBindingLayout>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "texture")) {
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::optional<
+            std::shared_ptr<GPUTextureBindingLayout>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "storageTexture")) {
+        auto prop = value.getProperty(runtime, "storageTexture");
+        result->storageTexture = JSIConverter<std::optional<
+            std::shared_ptr<GPUStorageTextureBindingLayout>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
+      }
+      if (value.hasProperty(runtime, "externalTexture")) {
+        auto prop = value.getProperty(runtime, "externalTexture");
+        result->externalTexture = JSIConverter<std::optional<
+            std::shared_ptr<GPUExternalTextureBindingLayout>>>::fromJSI(runtime,
+                                                                        prop,
+                                                                        false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupLayoutEntry::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBlendComponent.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBlendComponent {
+  std::optional<wgpu::BlendOperation> operation; // GPUBlendOperation
+  std::optional<wgpu::BlendFactor> srcFactor;    // GPUBlendFactor
+  std::optional<wgpu::BlendFactor> dstFactor;    // GPUBlendFactor
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendComponent>> {
+  static std::shared_ptr<rnwgpu::GPUBlendComponent>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBlendComponent>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "operation")) {
+        auto prop = value.getProperty(runtime, "operation");
+        result->operation =
+            JSIConverter<std::optional<wgpu::BlendOperation>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "srcFactor")) {
+        auto prop = value.getProperty(runtime, "srcFactor");
+        result->srcFactor =
+            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "dstFactor")) {
+        auto prop = value.getProperty(runtime, "dstFactor");
+        result->dstFactor =
+            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBlendComponent> arg) {
+    throw std::runtime_error("Invalid GPUBlendComponent::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBlendState.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "GPUBlendComponent.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBlendState {
+  std::shared_ptr<GPUBlendComponent> color; // GPUBlendComponent
+  std::shared_ptr<GPUBlendComponent> alpha; // GPUBlendComponent
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendState>> {
+  static std::shared_ptr<rnwgpu::GPUBlendState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBlendState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "color")) {
+        auto prop = value.getProperty(runtime, "color");
+        result->color =
+            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "alpha")) {
+        auto prop = value.getProperty(runtime, "alpha");
+        result->alpha =
+            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBlendState> arg) {
+    throw std::runtime_error("Invalid GPUBlendState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBufferBinding.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "rnwgpu/api/GPUBuffer.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBufferBinding {
+  std::shared_ptr<GPUBuffer> buffer; // GPUBuffer
+  std::optional<double> offset;      // GPUSize64
+  std::optional<double> size;        // GPUSize64
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBinding>> {
+  static std::shared_ptr<rnwgpu::GPUBufferBinding>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBufferBinding>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "buffer")) {
+        auto prop = value.getProperty(runtime, "buffer");
+        result->buffer = JSIConverter<std::shared_ptr<GPUBuffer>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "offset")) {
+        auto prop = value.getProperty(runtime, "offset");
+        result->offset =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "size")) {
+        auto prop = value.getProperty(runtime, "size");
+        result->size =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBufferBinding> arg) {
+    throw std::runtime_error("Invalid GPUBufferBinding::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBufferBindingLayout.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBufferBindingLayout {
+  std::optional<wgpu::BufferBindingType> type; // GPUBufferBindingType
+  std::optional<bool> hasDynamicOffset;        // boolean
+  std::optional<double> minBindingSize;        // GPUSize64
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBindingLayout>> {
+  static std::shared_ptr<rnwgpu::GPUBufferBindingLayout>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBufferBindingLayout>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "type")) {
+        auto prop = value.getProperty(runtime, "type");
+        result->type =
+            JSIConverter<std::optional<wgpu::BufferBindingType>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "hasDynamicOffset")) {
+        auto prop = value.getProperty(runtime, "hasDynamicOffset");
+        result->hasDynamicOffset =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "minBindingSize")) {
+        auto prop = value.getProperty(runtime, "minBindingSize");
+        result->minBindingSize =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBufferBindingLayout> arg) {
+    throw std::runtime_error("Invalid GPUBufferBindingLayout::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBufferDescriptor.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBufferDescriptor {
+  double size;                          // GPUSize64
+  double usage;                         // GPUBufferUsageFlags
+  std::optional<bool> mappedAtCreation; // boolean
+  std::optional<std::string> label;     // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUBufferDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBufferDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "size")) {
+        auto prop = value.getProperty(runtime, "size");
+        result->size = JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "usage")) {
+        auto prop = value.getProperty(runtime, "usage");
+        result->usage = JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "mappedAtCreation")) {
+        auto prop = value.getProperty(runtime, "mappedAtCreation");
+        result->mappedAtCreation =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBufferDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUBufferDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBufferUsage.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUBufferUsage {
+public:
+  static jsi::Object create(jsi::Runtime &runtime) {
+    jsi::Object obj(runtime);
+    obj.setProperty(runtime, "MAP_READ",
+                    static_cast<double>(wgpu::BufferUsage::MapRead));
+    obj.setProperty(runtime, "MAP_WRITE",
+                    static_cast<double>(wgpu::BufferUsage::MapWrite));
+    obj.setProperty(runtime, "COPY_SRC",
+                    static_cast<double>(wgpu::BufferUsage::CopySrc));
+    obj.setProperty(runtime, "COPY_DST",
+                    static_cast<double>(wgpu::BufferUsage::CopyDst));
+    obj.setProperty(runtime, "INDEX",
+                    static_cast<double>(wgpu::BufferUsage::Index));
+    obj.setProperty(runtime, "VERTEX",
+                    static_cast<double>(wgpu::BufferUsage::Vertex));
+    obj.setProperty(runtime, "UNIFORM",
+                    static_cast<double>(wgpu::BufferUsage::Uniform));
+    obj.setProperty(runtime, "STORAGE",
+                    static_cast<double>(wgpu::BufferUsage::Storage));
+    obj.setProperty(runtime, "INDIRECT",
+                    static_cast<double>(wgpu::BufferUsage::Indirect));
+    obj.setProperty(runtime, "QUERY_RESOLVE",
+                    static_cast<double>(wgpu::BufferUsage::QueryResolve));
+    return obj;
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUColor.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUColor {
+  double r; // number
+  double g; // number
+  double b; // number
+  double a; // number
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUColor>> {
+  static std::shared_ptr<rnwgpu::GPUColor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUColor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.isArray(runtime)) {
+        auto array = value.getArray(runtime);
+        if (array.size(runtime) >= 4) {
+          result->r = array.getValueAtIndex(runtime, 0).getNumber();
+          result->g = array.getValueAtIndex(runtime, 1).getNumber();
+          result->b = array.getValueAtIndex(runtime, 2).getNumber();
+          result->a = array.getValueAtIndex(runtime, 3).getNumber();
+        }
+      } else {
+        if (value.hasProperty(runtime, "r")) {
+          auto prop = value.getProperty(runtime, "r");
+          result->r = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+        if (value.hasProperty(runtime, "g")) {
+          auto prop = value.getProperty(runtime, "g");
+          result->g = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+        if (value.hasProperty(runtime, "b")) {
+          auto prop = value.getProperty(runtime, "b");
+          result->b = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+        if (value.hasProperty(runtime, "a")) {
+          auto prop = value.getProperty(runtime, "a");
+          result->a = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUColor> arg) {
+    throw std::runtime_error("Invalid GPUColor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUColorTargetState.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "GPUBlendState.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUColorTargetState {
+  wgpu::TextureFormat format;                          // GPUTextureFormat
+  std::optional<std::shared_ptr<GPUBlendState>> blend; // GPUBlendState
+  std::optional<double> writeMask;                     // GPUColorWriteFlags
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUColorTargetState>> {
+  static std::shared_ptr<rnwgpu::GPUColorTargetState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUColorTargetState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "format")) {
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "blend")) {
+        auto prop = value.getProperty(runtime, "blend");
+        result->blend = JSIConverter<
+            std::optional<std::shared_ptr<GPUBlendState>>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
+      }
+      if (value.hasProperty(runtime, "writeMask")) {
+        auto prop = value.getProperty(runtime, "writeMask");
+        result->writeMask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUColorTargetState> arg) {
+    throw std::runtime_error("Invalid GPUColorTargetState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUColorWrite.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUColorWrite {
+public:
+  static jsi::Object create(jsi::Runtime &runtime) {
+    jsi::Object obj(runtime);
+    obj.setProperty(runtime, "RED",
+                    static_cast<double>(wgpu::ColorWriteMask::Red));
+    obj.setProperty(runtime, "GREEN",
+                    static_cast<double>(wgpu::ColorWriteMask::Green));
+    obj.setProperty(runtime, "BLUE",
+                    static_cast<double>(wgpu::ColorWriteMask::Blue));
+    obj.setProperty(runtime, "ALPHA",
+                    static_cast<double>(wgpu::ColorWriteMask::Alpha));
+    obj.setProperty(runtime, "ALL",
+                    static_cast<double>(wgpu::ColorWriteMask::All));
+    return obj;
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUCommandBufferDescriptor.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUCommandBufferDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUCommandBufferDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUCommandBufferDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUCommandBufferDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUCommandBufferDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUCommandBufferDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu