react-native-wgpu 0.1.0

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

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUShaderModuleDescriptor {
+public:
+  wgpu::ShaderModuleDescriptor *getInstance() { return &_instance; }
+
+  wgpu::ShaderModuleDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 code = value.getProperty(runtime, "code");
+
+        if (code.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUShaderModuleDescriptor::code is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUShaderModuleDescriptor::code is not defined");
+      }
+      if (value.hasProperty(runtime, "sourceMap")) {
+        auto sourceMap = value.getProperty(runtime, "sourceMap");
+
+        if (sourceMap.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUShaderModuleDescriptor::sourceMap is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUShaderModuleDescriptor::sourceMap is not defined");
+      }
+      if (value.hasProperty(runtime, "compilationHints")) {
+        auto compilationHints = value.getProperty(runtime, "compilationHints");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUShaderModuleDescriptor::code = %f",
+                                 result->_instance.code);
+    rnwgpu::Logger::logToConsole("GPUShaderModuleDescriptor::sourceMap = %f",
+                                 result->_instance.sourceMap);
+    rnwgpu::Logger::logToConsole(
+        "GPUShaderModuleDescriptor::compilationHints = %f",
+        result->_instance.compilationHints);
+    rnwgpu::Logger::logToConsole("GPUShaderModuleDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,27 @@
+#pragma once
+#include <string>
+
+#include <RNFHybridObject.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUShaderStage : public m::HybridObject {
+public:
+  GPUShaderStage() : HybridObject("GPUShaderStage") {}
+
+public:
+  double Vertex() { return static_cast<double>(wgpu::ShaderStage::Vertex); }
+  double Fragment() { return static_cast<double>(wgpu::ShaderStage::Fragment); }
+  double Compute() { return static_cast<double>(wgpu::ShaderStage::Compute); }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("VERTEX", &GPUShaderStage::Vertex, this);
+    registerHybridGetter("FRAGMENT", &GPUShaderStage::Fragment, this);
+    registerHybridGetter("COMPUTE", &GPUShaderStage::Compute, this);
+  }
+};
+} // namespace rnwgpu

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

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUStencilFaceState {
+public:
+  wgpu::StencilFaceState *getInstance() { return &_instance; }
+
+  wgpu::StencilFaceState _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 compare = value.getProperty(runtime, "compare");
+      }
+      if (value.hasProperty(runtime, "failOp")) {
+        auto failOp = value.getProperty(runtime, "failOp");
+      }
+      if (value.hasProperty(runtime, "depthFailOp")) {
+        auto depthFailOp = value.getProperty(runtime, "depthFailOp");
+      }
+      if (value.hasProperty(runtime, "passOp")) {
+        auto passOp = value.getProperty(runtime, "passOp");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUStencilFaceState::compare = %f",
+                                 result->_instance.compare);
+    rnwgpu::Logger::logToConsole("GPUStencilFaceState::failOp = %f",
+                                 result->_instance.failOp);
+    rnwgpu::Logger::logToConsole("GPUStencilFaceState::depthFailOp = %f",
+                                 result->_instance.depthFailOp);
+    rnwgpu::Logger::logToConsole("GPUStencilFaceState::passOp = %f",
+                                 result->_instance.passOp);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUStencilFaceState> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUStorageTextureBindingLayout {
+public:
+  wgpu::StorageTextureBindingLayout *getInstance() { return &_instance; }
+
+  wgpu::StorageTextureBindingLayout _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 access = value.getProperty(runtime, "access");
+      }
+      if (value.hasProperty(runtime, "format")) {
+        auto format = value.getProperty(runtime, "format");
+
+        if (format.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUStorageTextureBindingLayout::format is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUStorageTextureBindingLayout::format is not defined");
+      }
+      if (value.hasProperty(runtime, "viewDimension")) {
+        auto viewDimension = value.getProperty(runtime, "viewDimension");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUStorageTextureBindingLayout::access = %f",
+                                 result->_instance.access);
+    rnwgpu::Logger::logToConsole("GPUStorageTextureBindingLayout::format = %f",
+                                 result->_instance.format);
+    rnwgpu::Logger::logToConsole(
+        "GPUStorageTextureBindingLayout::viewDimension = %f",
+        result->_instance.viewDimension);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUTextureBindingLayout {
+public:
+  wgpu::TextureBindingLayout *getInstance() { return &_instance; }
+
+  wgpu::TextureBindingLayout _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 sampleType = value.getProperty(runtime, "sampleType");
+      }
+      if (value.hasProperty(runtime, "viewDimension")) {
+        auto viewDimension = value.getProperty(runtime, "viewDimension");
+      }
+      if (value.hasProperty(runtime, "multisampled")) {
+        auto multisampled = value.getProperty(runtime, "multisampled");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUTextureBindingLayout::sampleType = %f",
+                                 result->_instance.sampleType);
+    rnwgpu::Logger::logToConsole("GPUTextureBindingLayout::viewDimension = %f",
+                                 result->_instance.viewDimension);
+    rnwgpu::Logger::logToConsole("GPUTextureBindingLayout::multisampled = %f",
+                                 result->_instance.multisampled);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUTextureBindingLayout> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUTextureDescriptor {
+public:
+  wgpu::TextureDescriptor *getInstance() { return &_instance; }
+
+  wgpu::TextureDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 size = value.getProperty(runtime, "size");
+
+        if (size.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUTextureDescriptor::size is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUTextureDescriptor::size is not defined");
+      }
+      if (value.hasProperty(runtime, "mipLevelCount")) {
+        auto mipLevelCount = value.getProperty(runtime, "mipLevelCount");
+
+        if (mipLevelCount.isNumber()) {
+          result->_instance.mipLevelCount =
+              static_cast<wgpu::IntegerCoordinate>(mipLevelCount.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "sampleCount")) {
+        auto sampleCount = value.getProperty(runtime, "sampleCount");
+
+        if (sampleCount.isNumber()) {
+          result->_instance.sampleCount =
+              static_cast<wgpu::Size32>(sampleCount.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "dimension")) {
+        auto dimension = value.getProperty(runtime, "dimension");
+      }
+      if (value.hasProperty(runtime, "format")) {
+        auto format = value.getProperty(runtime, "format");
+
+        if (format.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUTextureDescriptor::format is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUTextureDescriptor::format is not defined");
+      }
+      if (value.hasProperty(runtime, "usage")) {
+        auto usage = value.getProperty(runtime, "usage");
+
+        if (usage.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUTextureDescriptor::usage is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUTextureDescriptor::usage is not defined");
+      }
+      if (value.hasProperty(runtime, "viewFormats")) {
+        auto viewFormats = value.getProperty(runtime, "viewFormats");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::size = %f",
+                                 result->_instance.size);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::mipLevelCount = %f",
+                                 result->_instance.mipLevelCount);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::sampleCount = %f",
+                                 result->_instance.sampleCount);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::dimension = %f",
+                                 result->_instance.dimension);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::format = %f",
+                                 result->_instance.format);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::usage = %f",
+                                 result->_instance.usage);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::viewFormats = %f",
+                                 result->_instance.viewFormats);
+    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUTextureDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,40 @@
+#pragma once
+#include <string>
+
+#include <RNFHybridObject.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUTextureUsage : public m::HybridObject {
+public:
+  GPUTextureUsage() : HybridObject("GPUTextureUsage") {}
+
+public:
+  double CopySrc() { return static_cast<double>(wgpu::TextureUsage::CopySrc); }
+  double CopyDst() { return static_cast<double>(wgpu::TextureUsage::CopyDst); }
+  double TextureBinding() {
+    return static_cast<double>(wgpu::TextureUsage::TextureBinding);
+  }
+  double StorageBinding() {
+    return static_cast<double>(wgpu::TextureUsage::StorageBinding);
+  }
+  double RenderAttachment() {
+    return static_cast<double>(wgpu::TextureUsage::RenderAttachment);
+  }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("COPY_SRC", &GPUTextureUsage::CopySrc, this);
+    registerHybridGetter("COPY_DST", &GPUTextureUsage::CopyDst, this);
+    registerHybridGetter("TEXTURE_BINDING", &GPUTextureUsage::TextureBinding,
+                         this);
+    registerHybridGetter("STORAGE_BINDING", &GPUTextureUsage::StorageBinding,
+                         this);
+    registerHybridGetter("RENDER_ATTACHMENT",
+                         &GPUTextureUsage::RenderAttachment, this);
+  }
+};
+} // namespace rnwgpu

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

@@ -0,0 +1,113 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUTextureViewDescriptor {
+public:
+  wgpu::TextureViewDescriptor *getInstance() { return &_instance; }
+
+  wgpu::TextureViewDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 format = value.getProperty(runtime, "format");
+      }
+      if (value.hasProperty(runtime, "dimension")) {
+        auto dimension = value.getProperty(runtime, "dimension");
+      }
+      if (value.hasProperty(runtime, "aspect")) {
+        auto aspect = value.getProperty(runtime, "aspect");
+      }
+      if (value.hasProperty(runtime, "baseMipLevel")) {
+        auto baseMipLevel = value.getProperty(runtime, "baseMipLevel");
+
+        if (baseMipLevel.isNumber()) {
+          result->_instance.baseMipLevel =
+              static_cast<wgpu::IntegerCoordinate>(baseMipLevel.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "mipLevelCount")) {
+        auto mipLevelCount = value.getProperty(runtime, "mipLevelCount");
+
+        if (mipLevelCount.isNumber()) {
+          result->_instance.mipLevelCount =
+              static_cast<wgpu::IntegerCoordinate>(mipLevelCount.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "baseArrayLayer")) {
+        auto baseArrayLayer = value.getProperty(runtime, "baseArrayLayer");
+
+        if (baseArrayLayer.isNumber()) {
+          result->_instance.baseArrayLayer =
+              static_cast<wgpu::IntegerCoordinate>(baseArrayLayer.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "arrayLayerCount")) {
+        auto arrayLayerCount = value.getProperty(runtime, "arrayLayerCount");
+
+        if (arrayLayerCount.isNumber()) {
+          result->_instance.arrayLayerCount =
+              static_cast<wgpu::IntegerCoordinate>(arrayLayerCount.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::format = %f",
+                                 result->_instance.format);
+    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::dimension = %f",
+                                 result->_instance.dimension);
+    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::aspect = %f",
+                                 result->_instance.aspect);
+    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::baseMipLevel = %f",
+                                 result->_instance.baseMipLevel);
+    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::mipLevelCount = %f",
+                                 result->_instance.mipLevelCount);
+    rnwgpu::Logger::logToConsole(
+        "GPUTextureViewDescriptor::baseArrayLayer = %f",
+        result->_instance.baseArrayLayer);
+    rnwgpu::Logger::logToConsole(
+        "GPUTextureViewDescriptor::arrayLayerCount = %f",
+        result->_instance.arrayLayerCount);
+    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUTextureViewDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUUncapturedErrorEventInit {
+public:
+  wgpu::UncapturedErrorEventInit *getInstance() { return &_instance; }
+
+  wgpu::UncapturedErrorEventInit _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>> {
+  static std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUUncapturedErrorEventInit>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "error")) {
+        auto error = value.getProperty(runtime, "error");
+
+        if (error.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUUncapturedErrorEventInit::error is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUUncapturedErrorEventInit::error is not defined");
+      }
+      if (value.hasProperty(runtime, "bubbles")) {
+        auto bubbles = value.getProperty(runtime, "bubbles");
+      }
+      if (value.hasProperty(runtime, "cancelable")) {
+        auto cancelable = value.getProperty(runtime, "cancelable");
+      }
+      if (value.hasProperty(runtime, "composed")) {
+        auto composed = value.getProperty(runtime, "composed");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::error = %f",
+                                 result->_instance.error);
+    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::bubbles = %f",
+                                 result->_instance.bubbles);
+    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::cancelable = %f",
+                                 result->_instance.cancelable);
+    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::composed = %f",
+                                 result->_instance.composed);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo