react-native-wgpu 0.1.0 → 0.1.3

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

@@ -1,28 +1,31 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBufferBindingLayout {
-public:
-  wgpu::BufferBindingLayout *getInstance() { return &_instance; }
-
-  wgpu::BufferBindingLayout _instance;
+struct GPUBufferBindingLayout {
+  std::optional<wgpu::BufferBindingType> type; // GPUBufferBindingType
+  std::optional<bool> hasDynamicOffset;        // boolean
+  std::optional<double> minBindingSize;        // GPUSize64
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBindingLayout>> {
   static std::shared_ptr<rnwgpu::GPUBufferBindingLayout>
@@ -31,32 +34,29 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBindingLayout>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "type")) {
-        auto type = value.getProperty(runtime, "type");
+        auto prop = value.getProperty(runtime, "type");
+        result->type =
+            JSIConverter<std::optional<wgpu::BufferBindingType>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "hasDynamicOffset")) {
-        auto hasDynamicOffset = value.getProperty(runtime, "hasDynamicOffset");
+        auto prop = value.getProperty(runtime, "hasDynamicOffset");
+        result->hasDynamicOffset =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "minBindingSize")) {
-        auto minBindingSize = value.getProperty(runtime, "minBindingSize");
-
-        if (minBindingSize.isNumber()) {
-          result->_instance.minBindingSize = minBindingSize.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "minBindingSize");
+        result->minBindingSize =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBufferBindingLayout::type = %f",
-                                 result->_instance.type);
-    rnwgpu::Logger::logToConsole(
-        "GPUBufferBindingLayout::hasDynamicOffset = %f",
-        result->_instance.hasDynamicOffset);
-    rnwgpu::Logger::logToConsole("GPUBufferBindingLayout::minBindingSize = %f",
-                                 result->_instance.minBindingSize);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBufferBindingLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBufferBindingLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -5,26 +5,29 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBufferDescriptor {
-public:
-  wgpu::BufferDescriptor *getInstance() { return &_instance; }
-
-  wgpu::BufferDescriptor _instance;
-
-  std::string label;
+struct GPUBufferDescriptor {
+  double size;                          // GPUSize64
+  double usage;                         // GPUBufferUsageFlags
+  std::optional<bool> mappedAtCreation; // boolean
+  std::optional<std::string> label;     // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUBufferDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -32,54 +35,31 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferDescriptor>> {
     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 GPUBufferDescriptor::size is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBufferDescriptor::size is not defined");
+        auto prop = value.getProperty(runtime, "size");
+        result->size = JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "usage")) {
-        auto usage = value.getProperty(runtime, "usage");
-
-        if (usage.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBufferDescriptor::usage is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBufferDescriptor::usage is not defined");
+        auto prop = value.getProperty(runtime, "usage");
+        result->usage = JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "mappedAtCreation")) {
-        auto mappedAtCreation = value.getProperty(runtime, "mappedAtCreation");
+        auto prop = value.getProperty(runtime, "mappedAtCreation");
+        result->mappedAtCreation =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       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();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::size = %f",
-                                 result->_instance.size);
-    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::usage = %f",
-                                 result->_instance.usage);
-    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::mappedAtCreation = %f",
-                                 result->_instance.mappedAtCreation);
-    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBufferDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBufferDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,34 @@
 #pragma once
 
 #include <memory>
-#include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+
+#include "GPUDevice.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUCanvasConfiguration {
-public:
-  wgpu::CanvasConfiguration *getInstance() { return &_instance; }
-
-  wgpu::CanvasConfiguration _instance;
+struct GPUCanvasConfiguration {
+  std::shared_ptr<GPUDevice> device; // GPUDevice
+  wgpu::TextureFormat format;        // GPUTextureFormat
+  std::optional<double> usage;       // GPUTextureUsageFlags
+  std::optional<std::vector<wgpu::TextureFormat>>
+      viewFormats; // Iterable<GPUTextureFormat>
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces) // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
   static std::shared_ptr<rnwgpu::GPUCanvasConfiguration>
@@ -31,63 +37,35 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "device")) {
-        auto device = value.getProperty(runtime, "device");
-
-        if (device.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUCanvasConfiguration::device is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUCanvasConfiguration::device is not defined");
+        auto prop = value.getProperty(runtime, "device");
+        result->device = JSIConverter<std::shared_ptr<GPUDevice>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
-
-        if (format.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUCanvasConfiguration::format is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUCanvasConfiguration::format is not defined");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "usage")) {
-        auto usage = value.getProperty(runtime, "usage");
-
-        if (usage.isNumber()) {
-          result->_instance.usage =
-              static_cast<wgpu::TextureUsageFlags>(usage.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "usage");
+        result->usage =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "viewFormats")) {
-        auto viewFormats = value.getProperty(runtime, "viewFormats");
-      }
-      if (value.hasProperty(runtime, "colorSpace")) {
-        auto colorSpace = value.getProperty(runtime, "colorSpace");
-      }
-      if (value.hasProperty(runtime, "alphaMode")) {
-        auto alphaMode = value.getProperty(runtime, "alphaMode");
+        auto prop = value.getProperty(runtime, "viewFormats");
+        result->viewFormats = JSIConverter<
+            std::optional<std::vector<wgpu::TextureFormat>>>::fromJSI(runtime,
+                                                                      prop,
+                                                                      false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUCanvasConfiguration::device = %f",
-                                 result->_instance.device);
-    rnwgpu::Logger::logToConsole("GPUCanvasConfiguration::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole("GPUCanvasConfiguration::usage = %f",
-                                 result->_instance.usage);
-    rnwgpu::Logger::logToConsole("GPUCanvasConfiguration::viewFormats = %f",
-                                 result->_instance.viewFormats);
-    rnwgpu::Logger::logToConsole("GPUCanvasConfiguration::colorSpace = %f",
-                                 result->_instance.colorSpace);
-    rnwgpu::Logger::logToConsole("GPUCanvasConfiguration::alphaMode = %f",
-                                 result->_instance.alphaMode);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUCanvasConfiguration> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUCanvasConfiguration::toJSI()");
   }
 };
+
 } // namespace margelo

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFJSIConverter.h"
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
+
+namespace jsi = facebook::jsi;
+namespace m = margelo;
+
+namespace rnwgpu {
+
+struct GPUColor {
+  double r; // number
+  double g; // number
+  double b; // number
+  double a; // number
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUColor>> {
+  static std::shared_ptr<rnwgpu::GPUColor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUColor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.isArray(runtime)) {
+        auto array = value.getArray(runtime);
+        if (array.size(runtime) >= 4) {
+          result->r = array.getValueAtIndex(runtime, 0).getNumber();
+          result->g = array.getValueAtIndex(runtime, 1).getNumber();
+          result->b = array.getValueAtIndex(runtime, 2).getNumber();
+          result->a = array.getValueAtIndex(runtime, 3).getNumber();
+        }
+      } else {
+        if (value.hasProperty(runtime, "r")) {
+          auto prop = value.getProperty(runtime, "r");
+          result->r = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+        if (value.hasProperty(runtime, "g")) {
+          auto prop = value.getProperty(runtime, "g");
+          result->g = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+        if (value.hasProperty(runtime, "b")) {
+          auto prop = value.getProperty(runtime, "b");
+          result->b = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+        if (value.hasProperty(runtime, "a")) {
+          auto prop = value.getProperty(runtime, "a");
+          result->a = JSIConverter<double>::fromJSI(runtime, prop, false);
+        }
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUColor> arg) {
+    throw std::runtime_error("Invalid GPUColor::toJSI()");
+  }
+};
+
+} // namespace margelo

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

@@ -1,28 +1,32 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBlendState.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUColorTargetState {
-public:
-  wgpu::ColorTargetState *getInstance() { return &_instance; }
-
-  wgpu::ColorTargetState _instance;
+struct GPUColorTargetState {
+  wgpu::TextureFormat format;                          // GPUTextureFormat
+  std::optional<std::shared_ptr<GPUBlendState>> blend; // GPUBlendState
+  std::optional<double> writeMask;                     // GPUColorWriteFlags
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUColorTargetState>> {
   static std::shared_ptr<rnwgpu::GPUColorTargetState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,40 +34,30 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUColorTargetState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
-
-        if (format.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUColorTargetState::format is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUColorTargetState::format is not defined");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "blend")) {
-        auto blend = value.getProperty(runtime, "blend");
+        auto prop = value.getProperty(runtime, "blend");
+        result->blend = JSIConverter<
+            std::optional<std::shared_ptr<GPUBlendState>>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
       }
       if (value.hasProperty(runtime, "writeMask")) {
-        auto writeMask = value.getProperty(runtime, "writeMask");
-
-        if (writeMask.isNumber()) {
-          result->_instance.writeMask =
-              static_cast<wgpu::ColorWriteFlags>(writeMask.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "writeMask");
+        result->writeMask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUColorTargetState::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole("GPUColorTargetState::blend = %f",
-                                 result->_instance.blend);
-    rnwgpu::Logger::logToConsole("GPUColorTargetState::writeMask = %f",
-                                 result->_instance.writeMask);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUColorTargetState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUColorTargetState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFJSIConverter.h"
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
+
+namespace jsi = facebook::jsi;
+namespace m = margelo;
+
+namespace rnwgpu {
+
+struct GPUCommandBufferDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUCommandBufferDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUCommandBufferDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUCommandBufferDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUCommandBufferDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUCommandBufferDescriptor::toJSI()");
+  }
+};
+
+} // namespace margelo

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

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFJSIConverter.h"
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
+
+namespace jsi = facebook::jsi;
+namespace m = margelo;
+
+namespace rnwgpu {
+
+struct GPUCommandEncoderDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUCommandEncoderDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUCommandEncoderDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUCommandEncoderDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUCommandEncoderDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUCommandEncoderDescriptor::toJSI()");
+  }
+};
+
+} // namespace margelo

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

@@ -5,26 +5,29 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUComputePassTimestampWrites.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUComputePassDescriptor {
-public:
-  wgpu::ComputePassDescriptor *getInstance() { return &_instance; }
-
-  wgpu::ComputePassDescriptor _instance;
-
-  std::string label;
+struct GPUComputePassDescriptor {
+  std::optional<std::shared_ptr<GPUComputePassTimestampWrites>>
+      timestampWrites;              // GPUComputePassTimestampWrites
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUComputePassDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUComputePassDescriptor>
@@ -33,30 +36,26 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUComputePassDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "timestampWrites")) {
-        auto timestampWrites = value.getProperty(runtime, "timestampWrites");
+        auto prop = value.getProperty(runtime, "timestampWrites");
+        result->timestampWrites = JSIConverter<std::optional<
+            std::shared_ptr<GPUComputePassTimestampWrites>>>::fromJSI(runtime,
+                                                                      prop,
+                                                                      false);
       }
       if (value.hasProperty(runtime, "label")) {
-        auto 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();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole(
-        "GPUComputePassDescriptor::timestampWrites = %f",
-        result->_instance.timestampWrites);
-    rnwgpu::Logger::logToConsole("GPUComputePassDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUComputePassDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUComputePassDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo