react-native-wgpu 0.5.13 → 0.5.14

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

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.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

@@ -1,39 +0,0 @@
-#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/GPUCanvasConfiguration.h

@@ -1,76 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-
-#include "GPUDevice.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUCanvasConfiguration {
-  std::shared_ptr<GPUDevice> device; // GPUDevice
-  wgpu::TextureFormat format;        // GPUTextureFormat
-  std::optional<double> usage;       // GPUTextureUsageFlags
-  std::optional<std::vector<wgpu::TextureFormat>>
-      viewFormats; // Iterable<GPUTextureFormat>
-  wgpu::CompositeAlphaMode alphaMode = wgpu::CompositeAlphaMode::Opaque;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
-  static std::shared_ptr<rnwgpu::GPUCanvasConfiguration>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUCanvasConfiguration>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "device")) {
-        auto prop = value.getProperty(runtime, "device");
-        result->device = JSIConverter<std::shared_ptr<GPUDevice>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "usage")) {
-        auto prop = value.getProperty(runtime, "usage");
-        result->usage =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "viewFormats")) {
-        auto prop = value.getProperty(runtime, "viewFormats");
-        result->viewFormats = JSIConverter<
-            std::optional<std::vector<wgpu::TextureFormat>>>::fromJSI(runtime,
-                                                                      prop,
-                                                                      false);
-      }
-      if (value.hasProperty(runtime, "alphaMode")) {
-        auto prop = value.getProperty(runtime, "alphaMode")
-                        .asString(runtime)
-                        .utf8(runtime);
-        if (prop == "premultiplied") {
-          result->alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
-        }
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUCanvasConfiguration> arg) {
-    throw std::runtime_error("Invalid GPUCanvasConfiguration::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,67 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.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

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.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

@@ -1,29 +0,0 @@
-#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

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.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

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

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

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

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

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

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

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

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUPipelineLayout.h"
-#include "GPUProgrammableStage.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUComputePipelineDescriptor {
-  std::shared_ptr<GPUProgrammableStage> compute; // GPUProgrammableStage
-  std::variant<std::nullptr_t, std::shared_ptr<GPUPipelineLayout>>
-      layout;                       // | GPUPipelineLayout | GPUAutoLayoutMode
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUComputePipelineDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "compute")) {
-        auto prop = value.getProperty(runtime, "compute");
-        result->compute =
-            JSIConverter<std::shared_ptr<GPUProgrammableStage>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "layout")) {
-        auto prop = value.getProperty(runtime, "layout");
-        if (prop.isNull() || prop.isString()) {
-          result->layout = nullptr;
-        } else {
-          result->layout =
-              JSIConverter<std::shared_ptr<GPUPipelineLayout>>::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::GPUComputePipelineDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUComputePipelineDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
-// so the mapping to the native chained struct is 1:1. Chained onto the
-// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
-struct GPUDawnTogglesDescriptor {
-  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
-  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "enabledToggles")) {
-        auto prop = value.getProperty(runtime, "enabledToggles");
-        result->enabledToggles =
-            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "disabledToggles")) {
-        auto prop = value.getProperty(runtime, "disabledToggles");
-        result->disabledToggles =
-            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu