@shopify/react-native-skia 2.4.15 → 2.4.17

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <variant>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Convertors.h"
+#include "jsi2/JSIConverter.h"
+
+#include "GPUOrigin2D.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUImageCopyExternalImage {
+  //std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
+  std::optional<std::shared_ptr<GPUOrigin2D>> origin; // GPUOrigin2DStrict
+  std::optional<bool> flipY;                          // boolean
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
+    if (!outOfBounds && arg.isObject()) {
+      auto obj = arg.getObject(runtime);
+//      if (obj.hasProperty(runtime, "source")) {
+//        auto prop = obj.getProperty(runtime, "source");
+//        result->source = JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
+//            runtime, prop, false);
+//      }
+      if (obj.hasProperty(runtime, "origin")) {
+        auto prop = obj.getProperty(runtime, "origin");
+        result->origin = JSIConverter<std::shared_ptr<GPUOrigin2D>>::fromJSI(
+            runtime, prop, false);
+      }
+
+      if (obj.hasProperty(runtime, "flipY")) {
+        auto prop = obj.getProperty(runtime, "flipY");
+        result->flipY = JSIConverter<bool>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUImageCopyExternalImage> arg) {
+    throw std::runtime_error("Invalid GPUImageCopyExternalImage::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "GPUOrigin3D.h"
+#include "rnwgpu/api/GPUTexture.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUImageCopyTexture {
+  std::shared_ptr<GPUTexture> texture;                // GPUTexture
+  std::optional<double> mipLevel;                     // GPUIntegerCoordinate
+  std::optional<std::shared_ptr<GPUOrigin3D>> origin; // GPUOrigin3D
+  std::optional<wgpu::TextureAspect> aspect;          // GPUTextureAspect
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTexture>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyTexture>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyTexture>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "texture")) {
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::shared_ptr<GPUTexture>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "mipLevel")) {
+        auto prop = value.getProperty(runtime, "mipLevel");
+        result->mipLevel =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "origin")) {
+        auto prop = value.getProperty(runtime, "origin");
+        result->origin =
+            JSIConverter<std::optional<std::shared_ptr<GPUOrigin3D>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "aspect")) {
+        auto prop = value.getProperty(runtime, "aspect");
+        result->aspect =
+            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUImageCopyTexture> arg) {
+    throw std::runtime_error("Invalid GPUImageCopyTexture::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "External.h"
+#include "GPUOrigin3D.h"
+#include "rnwgpu/api/GPUTexture.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUImageCopyTextureTagged {
+  std::optional<PredefinedColorSpace> colorSpace;     // PredefinedColorSpace
+  std::optional<bool> premultipliedAlpha;             // boolean
+  std::shared_ptr<GPUTexture> texture;                // GPUTexture
+  std::optional<double> mipLevel;                     // GPUIntegerCoordinate
+  std::optional<std::shared_ptr<GPUOrigin3D>> origin; // GPUOrigin3D
+  std::optional<wgpu::TextureAspect> aspect;          // GPUTextureAspect
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyTextureTagged>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "colorSpace")) {
+        auto prop = value.getProperty(runtime, "colorSpace");
+        result->colorSpace =
+            JSIConverter<std::optional<PredefinedColorSpace>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "premultipliedAlpha")) {
+        auto prop = value.getProperty(runtime, "premultipliedAlpha");
+        result->premultipliedAlpha =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "texture")) {
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::shared_ptr<GPUTexture>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "mipLevel")) {
+        auto prop = value.getProperty(runtime, "mipLevel");
+        result->mipLevel =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "origin")) {
+        auto prop = value.getProperty(runtime, "origin");
+        result->origin =
+            JSIConverter<std::optional<std::shared_ptr<GPUOrigin3D>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "aspect")) {
+        auto prop = value.getProperty(runtime, "aspect");
+        result->aspect =
+            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged> arg) {
+    throw std::runtime_error("Invalid GPUImageCopyTextureTagged::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

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

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

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUMapMode {
+public:
+  static jsi::Object create(jsi::Runtime &runtime) {
+    jsi::Object obj(runtime);
+    obj.setProperty(runtime, "READ", static_cast<double>(wgpu::MapMode::Read));
+    obj.setProperty(runtime, "WRITE",
+                    static_cast<double>(wgpu::MapMode::Write));
+    return obj;
+  }
+};
+
+} // namespace rnwgpu

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

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

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

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

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

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUPrimitiveState {
+  std::optional<wgpu::PrimitiveTopology> topology;   // GPUPrimitiveTopology
+  std::optional<wgpu::IndexFormat> stripIndexFormat; // GPUIndexFormat
+  std::optional<wgpu::FrontFace> frontFace;          // GPUFrontFace
+  std::optional<wgpu::CullMode> cullMode;            // GPUCullMode
+  std::optional<bool> unclippedDepth;                // boolean
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUPrimitiveState>> {
+  static std::shared_ptr<rnwgpu::GPUPrimitiveState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUPrimitiveState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "topology")) {
+        auto prop = value.getProperty(runtime, "topology");
+        result->topology =
+            JSIConverter<std::optional<wgpu::PrimitiveTopology>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stripIndexFormat")) {
+        auto prop = value.getProperty(runtime, "stripIndexFormat");
+        result->stripIndexFormat =
+            JSIConverter<std::optional<wgpu::IndexFormat>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "frontFace")) {
+        auto prop = value.getProperty(runtime, "frontFace");
+        result->frontFace =
+            JSIConverter<std::optional<wgpu::FrontFace>>::fromJSI(runtime, prop,
+                                                                  false);
+      }
+      if (value.hasProperty(runtime, "cullMode")) {
+        auto prop = value.getProperty(runtime, "cullMode");
+        result->cullMode = JSIConverter<std::optional<wgpu::CullMode>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "unclippedDepth")) {
+        auto prop = value.getProperty(runtime, "unclippedDepth");
+        result->unclippedDepth =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUPrimitiveState> arg) {
+    throw std::runtime_error("Invalid GPUPrimitiveState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

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

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUQuerySetDescriptor {
+  wgpu::QueryType type;             // GPUQueryType
+  double count;                     // GPUSize32
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUQuerySetDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUQuerySetDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUQuerySetDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "type")) {
+        auto prop = value.getProperty(runtime, "type");
+        result->type =
+            JSIConverter<wgpu::QueryType>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "count")) {
+        auto prop = value.getProperty(runtime, "count");
+        result->count = JSIConverter<double>::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::GPUQuerySetDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUQuerySetDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUQueueDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUQueueDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUQueueDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUQueueDescriptor>();
+    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::GPUQueueDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUQueueDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPURenderBundleDescriptor.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 GPURenderBundleDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderBundleDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderBundleDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderBundleDescriptor>();
+    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::GPURenderBundleDescriptor> arg) {
+    throw std::runtime_error("Invalid GPURenderBundleDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu