@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

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

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPUColor.h"
-#include "rnwgpu/api/GPUTextureView.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPURenderPassColorAttachment {
-  std::shared_ptr<GPUTextureView> view; // GPUTextureView
-  std::optional<double> depthSlice;     // GPUIntegerCoordinate
-  std::optional<std::shared_ptr<GPUTextureView>>
-      resolveTarget;                                   // GPUTextureView
-  std::optional<std::shared_ptr<GPUColor>> clearValue; // GPUColor
-  wgpu::LoadOp loadOp;                                 // GPULoadOp
-  wgpu::StoreOp storeOp;                               // GPUStoreOp
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassColorAttachment>> {
-  static std::shared_ptr<rnwgpu::GPURenderPassColorAttachment>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPURenderPassColorAttachment>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "view")) {
-        auto prop = value.getProperty(runtime, "view");
-        result->view = JSIConverter<std::shared_ptr<GPUTextureView>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthSlice")) {
-        auto prop = value.getProperty(runtime, "depthSlice");
-        result->depthSlice =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "resolveTarget")) {
-        auto prop = value.getProperty(runtime, "resolveTarget");
-        result->resolveTarget = JSIConverter<
-            std::optional<std::shared_ptr<GPUTextureView>>>::fromJSI(runtime,
-                                                                     prop,
-                                                                     false);
-      }
-      if (value.hasProperty(runtime, "clearValue")) {
-        auto prop = value.getProperty(runtime, "clearValue");
-        result->clearValue =
-            JSIConverter<std::optional<std::shared_ptr<GPUColor>>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "loadOp")) {
-        auto prop = value.getProperty(runtime, "loadOp");
-        result->loadOp =
-            JSIConverter<wgpu::LoadOp>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "storeOp")) {
-        auto prop = value.getProperty(runtime, "storeOp");
-        result->storeOp =
-            JSIConverter<wgpu::StoreOp>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPURenderPassColorAttachment> arg) {
-    throw std::runtime_error("Invalid GPURenderPassColorAttachment::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,101 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/GPUTextureView.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPURenderPassDepthStencilAttachment {
-  std::shared_ptr<GPUTextureView> view;        // GPUTextureView
-  std::optional<double> depthClearValue;       // number
-  std::optional<wgpu::LoadOp> depthLoadOp;     // GPULoadOp
-  std::optional<wgpu::StoreOp> depthStoreOp;   // GPUStoreOp
-  std::optional<bool> depthReadOnly;           // boolean
-  std::optional<double> stencilClearValue;     // GPUStencilValue
-  std::optional<wgpu::LoadOp> stencilLoadOp;   // GPULoadOp
-  std::optional<wgpu::StoreOp> stencilStoreOp; // GPUStoreOp
-  std::optional<bool> stencilReadOnly;         // boolean
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<
-    std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment>> {
-  static std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result =
-        std::make_unique<rnwgpu::GPURenderPassDepthStencilAttachment>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "view")) {
-        auto prop = value.getProperty(runtime, "view");
-        result->view = JSIConverter<std::shared_ptr<GPUTextureView>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthClearValue")) {
-        auto prop = value.getProperty(runtime, "depthClearValue");
-        result->depthClearValue =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthLoadOp")) {
-        auto prop = value.getProperty(runtime, "depthLoadOp");
-        result->depthLoadOp =
-            JSIConverter<std::optional<wgpu::LoadOp>>::fromJSI(runtime, prop,
-                                                               false);
-      }
-      if (value.hasProperty(runtime, "depthStoreOp")) {
-        auto prop = value.getProperty(runtime, "depthStoreOp");
-        result->depthStoreOp =
-            JSIConverter<std::optional<wgpu::StoreOp>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      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, "stencilClearValue")) {
-        auto prop = value.getProperty(runtime, "stencilClearValue");
-        result->stencilClearValue =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stencilLoadOp")) {
-        auto prop = value.getProperty(runtime, "stencilLoadOp");
-        result->stencilLoadOp =
-            JSIConverter<std::optional<wgpu::LoadOp>>::fromJSI(runtime, prop,
-                                                               false);
-      }
-      if (value.hasProperty(runtime, "stencilStoreOp")) {
-        auto prop = value.getProperty(runtime, "stencilStoreOp");
-        result->stencilStoreOp =
-            JSIConverter<std::optional<wgpu::StoreOp>>::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);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment> arg) {
-    throw std::runtime_error(
-        "Invalid GPURenderPassDepthStencilAttachment::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,92 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPURenderPassColorAttachment.h"
-#include "GPURenderPassDepthStencilAttachment.h"
-#include "GPURenderPassTimestampWrites.h"
-#include "rnwgpu/api/GPUQuerySet.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPURenderPassDescriptor {
-  std::vector<std::variant<std::nullptr_t,
-                           std::shared_ptr<GPURenderPassColorAttachment>>>
-      colorAttachments; // Iterable<GPURenderPassColorAttachment | null>
-  std::optional<std::shared_ptr<GPURenderPassDepthStencilAttachment>>
-      depthStencilAttachment; // GPURenderPassDepthStencilAttachment
-  std::optional<std::shared_ptr<GPUQuerySet>> occlusionQuerySet; // GPUQuerySet
-  std::optional<std::shared_ptr<GPURenderPassTimestampWrites>>
-      timestampWrites;                // GPURenderPassTimestampWrites
-  std::optional<double> maxDrawCount; // GPUSize64
-  std::optional<std::string> label;   // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPURenderPassDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPURenderPassDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "colorAttachments")) {
-        auto prop = value.getProperty(runtime, "colorAttachments");
-        result->colorAttachments = JSIConverter<std::vector<std::variant<
-            std::nullptr_t, std::shared_ptr<GPURenderPassColorAttachment>>>>::
-            fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthStencilAttachment")) {
-        auto prop = value.getProperty(runtime, "depthStencilAttachment");
-        result->depthStencilAttachment =
-            JSIConverter<std::optional<std::shared_ptr<
-                GPURenderPassDepthStencilAttachment>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "occlusionQuerySet")) {
-        auto prop = value.getProperty(runtime, "occlusionQuerySet");
-        result->occlusionQuerySet =
-            JSIConverter<std::optional<std::shared_ptr<GPUQuerySet>>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "timestampWrites")) {
-        auto prop = value.getProperty(runtime, "timestampWrites");
-        result->timestampWrites = JSIConverter<std::optional<
-            std::shared_ptr<GPURenderPassTimestampWrites>>>::fromJSI(runtime,
-                                                                     prop,
-                                                                     false);
-      }
-      if (value.hasProperty(runtime, "maxDrawCount")) {
-        auto prop = value.getProperty(runtime, "maxDrawCount");
-        result->maxDrawCount =
-            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::GPURenderPassDescriptor> arg) {
-    throw std::runtime_error("Invalid GPURenderPassDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

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

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

@@ -1,103 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPUDepthStencilState.h"
-#include "GPUFragmentState.h"
-#include "GPUMultisampleState.h"
-#include "GPUPrimitiveState.h"
-#include "GPUVertexState.h"
-#include "rnwgpu/api/GPUPipelineLayout.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPURenderPipelineDescriptor {
-  std::shared_ptr<GPUVertexState> vertex; // GPUVertexState
-  std::optional<std::shared_ptr<GPUPrimitiveState>>
-      primitive; // GPUPrimitiveState
-  std::optional<std::shared_ptr<GPUDepthStencilState>>
-      depthStencil; // GPUDepthStencilState
-  std::optional<std::shared_ptr<GPUMultisampleState>>
-      multisample; // GPUMultisampleState
-  std::optional<std::shared_ptr<GPUFragmentState>> fragment; // GPUFragmentState
-  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::GPURenderPipelineDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPURenderPipelineDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "vertex")) {
-        auto prop = value.getProperty(runtime, "vertex");
-        result->vertex = JSIConverter<std::shared_ptr<GPUVertexState>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "primitive")) {
-        auto prop = value.getProperty(runtime, "primitive");
-        result->primitive = JSIConverter<
-            std::optional<std::shared_ptr<GPUPrimitiveState>>>::fromJSI(runtime,
-                                                                        prop,
-                                                                        false);
-      }
-      if (value.hasProperty(runtime, "depthStencil")) {
-        auto prop = value.getProperty(runtime, "depthStencil");
-        result->depthStencil =
-            JSIConverter<std::optional<std::shared_ptr<GPUDepthStencilState>>>::
-                fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "multisample")) {
-        auto prop = value.getProperty(runtime, "multisample");
-        result->multisample =
-            JSIConverter<std::optional<std::shared_ptr<GPUMultisampleState>>>::
-                fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "fragment")) {
-        auto prop = value.getProperty(runtime, "fragment");
-        result->fragment = JSIConverter<
-            std::optional<std::shared_ptr<GPUFragmentState>>>::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::GPURenderPipelineDescriptor> arg) {
-    throw std::runtime_error("Invalid GPURenderPipelineDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

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

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

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

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

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