react-native-wgpu 0.5.11 → 0.5.14

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -1,71 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <variant>
-
-#include "JSIConverter.h"
-#include "NativeObject.h"
-
-#include "GPUInternalError.h"
-#include "GPUOutOfMemoryError.h"
-#include "GPUValidationError.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-using GPUErrorVariant = std::variant<std::shared_ptr<GPUValidationError>,
-                                     std::shared_ptr<GPUOutOfMemoryError>,
-                                     std::shared_ptr<GPUInternalError>>;
-
-class GPUUncapturedErrorEvent : public NativeObject<GPUUncapturedErrorEvent> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUUncapturedErrorEvent";
-
-  explicit GPUUncapturedErrorEvent(GPUErrorVariant error)
-      : NativeObject(CLASS_NAME), _error(std::move(error)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getType() { return "uncapturederror"; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand",
-                  &GPUUncapturedErrorEvent::getBrand);
-    installGetter(runtime, prototype, "type",
-                  &GPUUncapturedErrorEvent::getType);
-
-    // Custom getter for error that handles the variant conversion
-    auto errorGetter = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "get_error"), 0,
-        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
-           size_t count) -> jsi::Value {
-          auto native = GPUUncapturedErrorEvent::fromValue(rt, thisVal);
-          return std::visit(
-              [&rt](auto &&err) -> jsi::Value {
-                using T = std::decay_t<decltype(err)>;
-                return JSIConverter<T>::toJSI(rt, err);
-              },
-              native->_error);
-        });
-
-    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
-    auto defineProperty =
-        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
-
-    jsi::Object descriptor(runtime);
-    descriptor.setProperty(runtime, "get", errorGetter);
-    descriptor.setProperty(runtime, "enumerable", true);
-    descriptor.setProperty(runtime, "configurable", true);
-
-    defineProperty.call(runtime, prototype,
-                        jsi::String::createFromUtf8(runtime, "error"),
-                        descriptor);
-  }
-
-private:
-  GPUErrorVariant _error;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUValidationError.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "NativeObject.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUValidationError : public NativeObject<GPUValidationError> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUValidationError";
-
-  explicit GPUValidationError(std::string message)
-      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUValidationError::getBrand);
-    installGetter(runtime, prototype, "message",
-                  &GPUValidationError::getMessage);
-  }
-
-private:
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "NativeObject.h"
-#include "PlatformContext.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class ImageBitmap : public NativeObject<ImageBitmap> {
-public:
-  static constexpr const char *CLASS_NAME = "ImageBitmap";
-
-  explicit ImageBitmap(ImageData &imageData)
-      : NativeObject(CLASS_NAME), _imageData(imageData) {}
-
-  size_t getWidth() { return _imageData.width; }
-
-  size_t getHeight() { return _imageData.height; }
-
-  void *getData() { return _imageData.data.data(); }
-
-  size_t getSize() { return _imageData.data.size(); }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "width", &ImageBitmap::getWidth);
-    installGetter(runtime, prototype, "height", &ImageBitmap::getHeight);
-  }
-
-  size_t getMemoryPressure() override { return getSize(); }
-
-private:
-  ImageData _imageData;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -1,199 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "NativeObject.h"
-
-#include "Canvas.h"
-#include "GPU.h"
-#include "GPUCanvasContext.h"
-#include "ImageBitmap.h"
-#include "PlatformContext.h"
-
-#include <ReactCommon/CallInvoker.h>
-
-#include "JSIConverter.h"
-#include "Promise.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-struct Blob {
-  std::string blobId;
-  double size;
-  double offset;
-  std::string type;
-  std::string name;
-};
-
-// JSIConverter specialization must be declared before use
-template <> struct JSIConverter<std::shared_ptr<Blob>> {
-  static std::shared_ptr<Blob>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    if (!outOfBounds && arg.isObject()) {
-      auto result = std::make_unique<Blob>();
-      auto val = arg.asObject(runtime);
-      if (val.hasProperty(runtime, "_data")) {
-        auto value = val.getPropertyAsObject(runtime, "_data");
-        result->blobId = JSIConverter<std::string>::fromJSI(
-            runtime, value.getProperty(runtime, "blobId"), false);
-        result->size = JSIConverter<double>::fromJSI(
-            runtime, value.getProperty(runtime, "size"), false);
-        result->offset = JSIConverter<double>::fromJSI(
-            runtime, value.getProperty(runtime, "offset"), false);
-      }
-      return result;
-    } else {
-      throw std::runtime_error("Invalid Blob::fromJSI()");
-    }
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime, std::shared_ptr<Blob> arg) {
-    throw std::runtime_error("Invalid Blob::toJSI()");
-  }
-};
-
-class RNWebGPU : public NativeObject<RNWebGPU> {
-public:
-  static constexpr const char *CLASS_NAME = "RNWebGPU";
-
-  explicit RNWebGPU(std::shared_ptr<GPU> gpu,
-                    std::shared_ptr<PlatformContext> platformContext,
-                    std::shared_ptr<facebook::react::CallInvoker> callInvoker)
-      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext),
-        _callInvoker(callInvoker) {}
-
-  std::shared_ptr<GPU> getGPU() { return _gpu; }
-
-  bool getFabric() { return true; }
-
-  std::shared_ptr<GPUCanvasContext>
-  MakeWebGPUCanvasContext(int contextId, float width, float height) {
-    auto ctx =
-        std::make_shared<GPUCanvasContext>(_gpu, contextId, width, height);
-    return ctx;
-  }
-
-  jsi::Value createImageBitmap(jsi::Runtime &runtime,
-                               const jsi::Value & /*thisVal*/,
-                               const jsi::Value *args, size_t count) {
-    if (count < 1) {
-      throw jsi::JSError(runtime,
-                         "createImageBitmap requires a Blob or ArrayBuffer "
-                         "argument");
-    }
-
-    auto platformContext = _platformContext;
-    auto callInvoker = _callInvoker;
-
-    // Check if the argument is an ArrayBuffer or ArrayBufferView
-    // (TypedArray / DataView)
-    if (args[0].isObject()) {
-      auto obj = args[0].getObject(runtime);
-
-      std::span<const uint8_t> data;
-
-      if (obj.isArrayBuffer(runtime)) {
-        // Plain ArrayBuffer — use the full buffer
-        const auto &ab = obj.getArrayBuffer(runtime);
-        data = {ab.data(runtime), ab.size(runtime)};
-      } else if (obj.hasProperty(runtime, "buffer")) {
-        // TypedArray or DataView — respect byteOffset/byteLength
-        auto bufferVal = obj.getProperty(runtime, "buffer");
-        if (bufferVal.isObject() &&
-            bufferVal.getObject(runtime).isArrayBuffer(runtime)) {
-          const auto &ab = bufferVal.getObject(runtime).getArrayBuffer(runtime);
-          auto byteOffset = static_cast<size_t>(
-              obj.getProperty(runtime, "byteOffset").asNumber());
-          auto byteLength = static_cast<size_t>(
-              obj.getProperty(runtime, "byteLength").asNumber());
-          data = {ab.data(runtime) + byteOffset, byteLength};
-        }
-      }
-
-      if (!data.empty()) {
-        // Copy bytes on the JS thread — the ArrayBuffer pointer is into
-        // JS-owned memory that can be GC'd
-        std::vector<uint8_t> dataCopy(data.begin(), data.end());
-
-        return Promise::createPromise(
-            runtime,
-            [platformContext, callInvoker, dataCopy = std::move(dataCopy)](
-                jsi::Runtime & /*runtime*/,
-                std::shared_ptr<Promise> promise) mutable {
-              platformContext->createImageBitmapFromDataAsync(
-                  dataCopy,
-                  [callInvoker, promise](ImageData imageData) {
-                    auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
-                    callInvoker->invokeAsync([promise, imageBitmap]() {
-                      promise->resolve(
-                          JSIConverter<std::shared_ptr<ImageBitmap>>::toJSI(
-                              promise->runtime, imageBitmap));
-                    });
-                  },
-                  [callInvoker, promise](std::string error) {
-                    callInvoker->invokeAsync(
-                        [promise, error]() { promise->reject(error); });
-                  });
-            });
-      }
-    }
-
-    // Fall through to existing Blob path
-    auto blob =
-        JSIConverter<std::shared_ptr<Blob>>::fromJSI(runtime, args[0], false);
-    std::string blobId = blob->blobId;
-    double offset = blob->offset;
-    double size = blob->size;
-
-    return Promise::createPromise(
-        runtime,
-        [platformContext, callInvoker, blobId, offset,
-         size](jsi::Runtime & /*runtime*/, std::shared_ptr<Promise> promise) {
-          platformContext->createImageBitmapAsync(
-              blobId, offset, size,
-              [callInvoker, promise](ImageData imageData) {
-                auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
-                callInvoker->invokeAsync([promise, imageBitmap]() {
-                  promise->resolve(
-                      JSIConverter<std::shared_ptr<ImageBitmap>>::toJSI(
-                          promise->runtime, imageBitmap));
-                });
-              },
-              [callInvoker, promise](std::string error) {
-                callInvoker->invokeAsync(
-                    [promise, error]() { promise->reject(error); });
-              });
-        });
-  }
-
-  std::shared_ptr<Canvas> getNativeSurface(int contextId) {
-    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-    auto info = registry.getSurfaceInfo(contextId);
-    if (info == nullptr) {
-      return std::make_shared<Canvas>(nullptr, 0, 0);
-    }
-    auto nativeInfo = info->getNativeInfo();
-    return std::make_shared<Canvas>(nativeInfo.nativeSurface, nativeInfo.width,
-                                    nativeInfo.height);
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "fabric", &RNWebGPU::getFabric);
-    installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
-    installMethod(runtime, prototype, "createImageBitmap",
-                  &RNWebGPU::createImageBitmap);
-    installMethod(runtime, prototype, "getNativeSurface",
-                  &RNWebGPU::getNativeSurface);
-    installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
-                  &RNWebGPU::MakeWebGPUCanvasContext);
-  }
-
-private:
-  std::shared_ptr<GPU> _gpu;
-  std::shared_ptr<PlatformContext> _platformContext;
-  std::shared_ptr<facebook::react::CallInvoker> _callInvoker;
-};
-
-} // namespace rnwgpu

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

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

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

@@ -1,78 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <variant>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBufferBinding.h"
-#include "GPUExternalTexture.h"
-#include "GPUSampler.h"
-#include "GPUTextureView.h"
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupEntry {
-  double binding;
-  std::shared_ptr<GPUSampler> sampler = nullptr;
-  std::shared_ptr<GPUTextureView> textureView = nullptr;
-  std::shared_ptr<GPUBufferBinding> buffer = nullptr;
-  // external textures
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupEntry>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "binding")) {
-        result->binding = value.getProperty(runtime, "binding").asNumber();
-      }
-      if (value.hasProperty(runtime, "resource")) {
-        auto prop = value.getProperty(runtime, "resource");
-        if (prop.isObject()) {
-          auto obj = prop.getObject(runtime);
-          if (obj.hasNativeState<rnwgpu::GPUSampler>(runtime)) {
-            result->sampler = obj.getNativeState<rnwgpu::GPUSampler>(runtime);
-          } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
-            result->textureView =
-                obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
-          } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
-            // Support passing GPUBuffer directly as resource (auto-wrap in
-            // GPUBufferBinding)
-            auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
-            binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);
-            result->buffer = binding;
-          } else {
-            result->buffer = JSIConverter<
-                std::shared_ptr<rnwgpu::GPUBufferBinding>>::fromJSI(runtime,
-                                                                    prop,
-                                                                    false);
-          }
-        }
-        // result->resource = JSIConverter<std::variant<
-        //     std::shared_ptr<GPUSampler>, std::shared_ptr<GPUTextureView>,
-        //     std::shared_ptr<GPUBufferBinding>,
-        //     std::shared_ptr<GPUExternalTexture>>>::fromJSI(runtime, prop,
-        //                                                    false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBindGroupEntry> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupEntry::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

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

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

@@ -1,98 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUBufferBindingLayout.h"
-#include "GPUExternalTextureBindingLayout.h"
-#include "GPUSamplerBindingLayout.h"
-#include "GPUStorageTextureBindingLayout.h"
-#include "GPUTextureBindingLayout.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupLayoutEntry {
-  double binding;    // GPUIndex32
-  double visibility; // GPUShaderStageFlags
-  std::optional<std::shared_ptr<GPUBufferBindingLayout>>
-      buffer; // GPUBufferBindingLayout
-  std::optional<std::shared_ptr<GPUSamplerBindingLayout>>
-      sampler; // GPUSamplerBindingLayout
-  std::optional<std::shared_ptr<GPUTextureBindingLayout>>
-      texture; // GPUTextureBindingLayout
-  std::optional<std::shared_ptr<GPUStorageTextureBindingLayout>>
-      storageTexture; // GPUStorageTextureBindingLayout
-  std::optional<std::shared_ptr<GPUExternalTextureBindingLayout>>
-      externalTexture; // GPUExternalTextureBindingLayout
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutEntry>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "binding")) {
-        auto prop = value.getProperty(runtime, "binding");
-        result->binding = JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "visibility")) {
-        auto prop = value.getProperty(runtime, "visibility");
-        result->visibility =
-            JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "buffer")) {
-        auto prop = value.getProperty(runtime, "buffer");
-        result->buffer = JSIConverter<std::optional<
-            std::shared_ptr<GPUBufferBindingLayout>>>::fromJSI(runtime, prop,
-                                                               false);
-      }
-      if (value.hasProperty(runtime, "sampler")) {
-        auto prop = value.getProperty(runtime, "sampler");
-        result->sampler = JSIConverter<std::optional<
-            std::shared_ptr<GPUSamplerBindingLayout>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "texture")) {
-        auto prop = value.getProperty(runtime, "texture");
-        result->texture = JSIConverter<std::optional<
-            std::shared_ptr<GPUTextureBindingLayout>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "storageTexture")) {
-        auto prop = value.getProperty(runtime, "storageTexture");
-        result->storageTexture = JSIConverter<std::optional<
-            std::shared_ptr<GPUStorageTextureBindingLayout>>>::fromJSI(runtime,
-                                                                       prop,
-                                                                       false);
-      }
-      if (value.hasProperty(runtime, "externalTexture")) {
-        auto prop = value.getProperty(runtime, "externalTexture");
-        result->externalTexture = JSIConverter<std::optional<
-            std::shared_ptr<GPUExternalTextureBindingLayout>>>::fromJSI(runtime,
-                                                                        prop,
-                                                                        false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupLayoutEntry::toJSI()");
-  }
-};
-
-} // namespace rnwgpu