react-native-wgpu 0.5.11 → 0.5.14

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

@@ -1,111 +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 GPUSamplerDescriptor {
-  std::optional<wgpu::AddressMode> addressModeU;      // GPUAddressMode
-  std::optional<wgpu::AddressMode> addressModeV;      // GPUAddressMode
-  std::optional<wgpu::AddressMode> addressModeW;      // GPUAddressMode
-  std::optional<wgpu::FilterMode> magFilter;          // GPUFilterMode
-  std::optional<wgpu::FilterMode> minFilter;          // GPUFilterMode
-  std::optional<wgpu::MipmapFilterMode> mipmapFilter; // GPUMipmapFilterMode
-  std::optional<double> lodMinClamp;                  // number
-  std::optional<double> lodMaxClamp;                  // number
-  std::optional<wgpu::CompareFunction> compare;       // GPUCompareFunction
-  std::optional<double> maxAnisotropy;                // number
-  std::optional<std::string> label;                   // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUSamplerDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUSamplerDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "addressModeU")) {
-        auto prop = value.getProperty(runtime, "addressModeU");
-        result->addressModeU =
-            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "addressModeV")) {
-        auto prop = value.getProperty(runtime, "addressModeV");
-        result->addressModeV =
-            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "addressModeW")) {
-        auto prop = value.getProperty(runtime, "addressModeW");
-        result->addressModeW =
-            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "magFilter")) {
-        auto prop = value.getProperty(runtime, "magFilter");
-        result->magFilter =
-            JSIConverter<std::optional<wgpu::FilterMode>>::fromJSI(runtime,
-                                                                   prop, false);
-      }
-      if (value.hasProperty(runtime, "minFilter")) {
-        auto prop = value.getProperty(runtime, "minFilter");
-        result->minFilter =
-            JSIConverter<std::optional<wgpu::FilterMode>>::fromJSI(runtime,
-                                                                   prop, false);
-      }
-      if (value.hasProperty(runtime, "mipmapFilter")) {
-        auto prop = value.getProperty(runtime, "mipmapFilter");
-        result->mipmapFilter =
-            JSIConverter<std::optional<wgpu::MipmapFilterMode>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "lodMinClamp")) {
-        auto prop = value.getProperty(runtime, "lodMinClamp");
-        result->lodMinClamp =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "lodMaxClamp")) {
-        auto prop = value.getProperty(runtime, "lodMaxClamp");
-        result->lodMaxClamp =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "compare")) {
-        auto prop = value.getProperty(runtime, "compare");
-        result->compare =
-            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "maxAnisotropy")) {
-        auto prop = value.getProperty(runtime, "maxAnisotropy");
-        result->maxAnisotropy =
-            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::GPUSamplerDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUSamplerDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

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

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

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

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

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUShaderStage {
-public:
-  static jsi::Object create(jsi::Runtime &runtime) {
-    jsi::Object obj(runtime);
-    obj.setProperty(runtime, "VERTEX",
-                    static_cast<double>(wgpu::ShaderStage::Vertex));
-    obj.setProperty(runtime, "FRAGMENT",
-                    static_cast<double>(wgpu::ShaderStage::Fragment));
-    obj.setProperty(runtime, "COMPUTE",
-                    static_cast<double>(wgpu::ShaderStage::Compute));
-    return obj;
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUStencilFaceState {
-  std::optional<wgpu::CompareFunction> compare;      // GPUCompareFunction
-  std::optional<wgpu::StencilOperation> failOp;      // GPUStencilOperation
-  std::optional<wgpu::StencilOperation> depthFailOp; // GPUStencilOperation
-  std::optional<wgpu::StencilOperation> passOp;      // GPUStencilOperation
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUStencilFaceState>> {
-  static std::shared_ptr<rnwgpu::GPUStencilFaceState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUStencilFaceState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "compare")) {
-        auto prop = value.getProperty(runtime, "compare");
-        result->compare =
-            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "failOp")) {
-        auto prop = value.getProperty(runtime, "failOp");
-        result->failOp =
-            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthFailOp")) {
-        auto prop = value.getProperty(runtime, "depthFailOp");
-        result->depthFailOp =
-            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "passOp")) {
-        auto prop = value.getProperty(runtime, "passOp");
-        result->passOp =
-            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUStencilFaceState> arg) {
-    throw std::runtime_error("Invalid GPUStencilFaceState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUStorageTextureBindingLayout {
-  std::optional<wgpu::StorageTextureAccess> access; // GPUStorageTextureAccess
-  wgpu::TextureFormat format;                       // GPUTextureFormat
-  std::optional<wgpu::TextureViewDimension>
-      viewDimension; // GPUTextureViewDimension
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>> {
-  static std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUStorageTextureBindingLayout>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "access")) {
-        auto prop = value.getProperty(runtime, "access");
-        result->access =
-            JSIConverter<std::optional<wgpu::StorageTextureAccess>>::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, "viewDimension")) {
-        auto prop = value.getProperty(runtime, "viewDimension");
-        result->viewDimension =
-            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout> arg) {
-    throw std::runtime_error("Invalid GPUStorageTextureBindingLayout::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUTextureBindingLayout {
-  std::optional<wgpu::TextureSampleType> sampleType; // GPUTextureSampleType
-  std::optional<wgpu::TextureViewDimension>
-      viewDimension;                // GPUTextureViewDimension
-  std::optional<bool> multisampled; // boolean
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureBindingLayout>> {
-  static std::shared_ptr<rnwgpu::GPUTextureBindingLayout>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUTextureBindingLayout>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "sampleType")) {
-        auto prop = value.getProperty(runtime, "sampleType");
-        result->sampleType =
-            JSIConverter<std::optional<wgpu::TextureSampleType>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "viewDimension")) {
-        auto prop = value.getProperty(runtime, "viewDimension");
-        result->viewDimension =
-            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "multisampled")) {
-        auto prop = value.getProperty(runtime, "multisampled");
-        result->multisampled =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUTextureBindingLayout> arg) {
-    throw std::runtime_error("Invalid GPUTextureBindingLayout::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,92 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUExtent3D.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUTextureDescriptor {
-  std::shared_ptr<GPUExtent3D> size;               // GPUExtent3DStrict
-  std::optional<double> mipLevelCount;             // GPUIntegerCoordinate
-  std::optional<double> sampleCount;               // GPUSize32
-  std::optional<wgpu::TextureDimension> dimension; // GPUTextureDimension
-  wgpu::TextureFormat format;                      // GPUTextureFormat
-  double usage;                                    // GPUTextureUsageFlags
-  std::optional<std::vector<wgpu::TextureFormat>>
-      viewFormats;                  // Iterable<GPUTextureFormat>
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUTextureDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUTextureDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "size")) {
-        auto prop = value.getProperty(runtime, "size");
-        result->size = JSIConverter<std::shared_ptr<GPUExtent3D>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "mipLevelCount")) {
-        auto prop = value.getProperty(runtime, "mipLevelCount");
-        result->mipLevelCount =
-            JSIConverter<std::optional<double>>::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, "dimension")) {
-        auto prop = value.getProperty(runtime, "dimension");
-        result->dimension =
-            JSIConverter<std::optional<wgpu::TextureDimension>>::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<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, "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::GPUTextureDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUTextureDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUTextureUsage {
-public:
-  static jsi::Object create(jsi::Runtime &runtime) {
-    jsi::Object obj(runtime);
-    obj.setProperty(runtime, "COPY_SRC",
-                    static_cast<double>(wgpu::TextureUsage::CopySrc));
-    obj.setProperty(runtime, "COPY_DST",
-                    static_cast<double>(wgpu::TextureUsage::CopyDst));
-    obj.setProperty(runtime, "TEXTURE_BINDING",
-                    static_cast<double>(wgpu::TextureUsage::TextureBinding));
-    obj.setProperty(runtime, "STORAGE_BINDING",
-                    static_cast<double>(wgpu::TextureUsage::StorageBinding));
-    obj.setProperty(runtime, "RENDER_ATTACHMENT",
-                    static_cast<double>(wgpu::TextureUsage::RenderAttachment));
-    return obj;
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,92 +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 GPUTextureViewDescriptor {
-  std::optional<wgpu::TextureFormat> format; // GPUTextureFormat
-  std::optional<wgpu::TextureViewDimension>
-      dimension;                             // GPUTextureViewDimension
-  std::optional<wgpu::TextureAspect> aspect; // GPUTextureAspect
-  std::optional<double> baseMipLevel;        // GPUIntegerCoordinate
-  std::optional<double> mipLevelCount;       // GPUIntegerCoordinate
-  std::optional<double> baseArrayLayer;      // GPUIntegerCoordinate
-  std::optional<double> arrayLayerCount;     // GPUIntegerCoordinate
-  std::optional<std::string> label;          // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUTextureViewDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<std::optional<wgpu::TextureFormat>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "dimension")) {
-        auto prop = value.getProperty(runtime, "dimension");
-        result->dimension =
-            JSIConverter<std::optional<wgpu::TextureViewDimension>>::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);
-      }
-      if (value.hasProperty(runtime, "baseMipLevel")) {
-        auto prop = value.getProperty(runtime, "baseMipLevel");
-        result->baseMipLevel =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "mipLevelCount")) {
-        auto prop = value.getProperty(runtime, "mipLevelCount");
-        result->mipLevelCount =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "baseArrayLayer")) {
-        auto prop = value.getProperty(runtime, "baseArrayLayer");
-        result->baseArrayLayer =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "arrayLayerCount")) {
-        auto prop = value.getProperty(runtime, "arrayLayerCount");
-        result->arrayLayerCount =
-            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::GPUTextureViewDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUTextureViewDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu