@shopify/react-native-skia 2.10.0 → 2.10.1

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

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/External.h"
-#include "rnwgpu/api/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

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

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

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

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

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

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

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

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

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

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

@@ -1,80 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPURenderBundleEncoderDescriptor {
-  std::optional<bool> depthReadOnly;   // boolean
-  std::optional<bool> stencilReadOnly; // boolean
-  std::vector<std::variant<std::nullptr_t, wgpu::TextureFormat>>
-      colorFormats; // Iterable<GPUTextureFormat | null>
-  std::optional<wgpu::TextureFormat> depthStencilFormat; // GPUTextureFormat
-  std::optional<double> sampleCount;                     // GPUSize32
-  std::optional<std::string> label;                      // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPURenderBundleEncoderDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "depthReadOnly")) {
-        auto prop = value.getProperty(runtime, "depthReadOnly");
-        result->depthReadOnly =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stencilReadOnly")) {
-        auto prop = value.getProperty(runtime, "stencilReadOnly");
-        result->stencilReadOnly =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "colorFormats")) {
-        auto prop = value.getProperty(runtime, "colorFormats");
-        result->colorFormats = JSIConverter<
-            std::vector<std::variant<std::nullptr_t, wgpu::TextureFormat>>>::
-            fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthStencilFormat")) {
-        auto prop = value.getProperty(runtime, "depthStencilFormat");
-        result->depthStencilFormat =
-            JSIConverter<std::optional<wgpu::TextureFormat>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "sampleCount")) {
-        auto prop = value.getProperty(runtime, "sampleCount");
-        result->sampleCount =
-            JSIConverter<std::optional<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::GPURenderBundleEncoderDescriptor> arg) {
-    throw std::runtime_error(
-        "Invalid GPURenderBundleEncoderDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu