@shopify/react-native-skia 2.9.1 → 2.10.1

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

@@ -1,91 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUTextureViewDescriptor {
-  std::optional<wgpu::TextureFormat> format; // GPUTextureFormat
-  std::optional<wgpu::TextureViewDimension>
-      dimension;                             // GPUTextureViewDimension
-  std::optional<wgpu::TextureAspect> aspect; // GPUTextureAspect
-  std::optional<double> baseMipLevel;        // GPUIntegerCoordinate
-  std::optional<double> mipLevelCount;       // GPUIntegerCoordinate
-  std::optional<double> baseArrayLayer;      // GPUIntegerCoordinate
-  std::optional<double> arrayLayerCount;     // GPUIntegerCoordinate
-  std::optional<std::string> label;          // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUTextureViewDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<std::optional<wgpu::TextureFormat>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "dimension")) {
-        auto prop = value.getProperty(runtime, "dimension");
-        result->dimension =
-            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "aspect")) {
-        auto prop = value.getProperty(runtime, "aspect");
-        result->aspect =
-            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "baseMipLevel")) {
-        auto prop = value.getProperty(runtime, "baseMipLevel");
-        result->baseMipLevel =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "mipLevelCount")) {
-        auto prop = value.getProperty(runtime, "mipLevelCount");
-        result->mipLevelCount =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "baseArrayLayer")) {
-        auto prop = value.getProperty(runtime, "baseArrayLayer");
-        result->baseArrayLayer =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "arrayLayerCount")) {
-        auto prop = value.getProperty(runtime, "arrayLayerCount");
-        result->arrayLayerCount =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "label")) {
-        auto prop = value.getProperty(runtime, "label");
-        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
-            runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUTextureViewDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUTextureViewDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "rnwgpu/api/GPUError.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUUncapturedErrorEventInit {
-  std::shared_ptr<GPUError> error; // GPUError
-  std::optional<bool> bubbles;     // boolean
-  std::optional<bool> cancelable;  // boolean
-  std::optional<bool> composed;    // boolean
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-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 prop = value.getProperty(runtime, "error");
-        result->error = JSIConverter<std::shared_ptr<GPUError>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "bubbles")) {
-        auto prop = value.getProperty(runtime, "bubbles");
-        result->bubbles =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "cancelable")) {
-        auto prop = value.getProperty(runtime, "cancelable");
-        result->cancelable =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "composed")) {
-        auto prop = value.getProperty(runtime, "composed");
-        result->composed =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit> arg) {
-    throw std::runtime_error("Invalid GPUUncapturedErrorEventInit::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUVertexAttribute {
-  wgpu::VertexFormat format; // GPUVertexFormat
-  double offset;             // GPUSize64
-  double shaderLocation;     // GPUIndex32
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexAttribute>> {
-  static std::shared_ptr<rnwgpu::GPUVertexAttribute>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUVertexAttribute>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<wgpu::VertexFormat>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "offset")) {
-        auto prop = value.getProperty(runtime, "offset");
-        result->offset = JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "shaderLocation")) {
-        auto prop = value.getProperty(runtime, "shaderLocation");
-        result->shaderLocation =
-            JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUVertexAttribute> arg) {
-    throw std::runtime_error("Invalid GPUVertexAttribute::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,62 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "GPUVertexAttribute.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUVertexBufferLayout {
-  double arrayStride;                           // GPUSize64
-  std::optional<wgpu::VertexStepMode> stepMode; // GPUVertexStepMode
-  std::vector<std::shared_ptr<GPUVertexAttribute>>
-      attributes; // Iterable<GPUVertexAttribute>
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexBufferLayout>> {
-  static std::shared_ptr<rnwgpu::GPUVertexBufferLayout>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUVertexBufferLayout>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "arrayStride")) {
-        auto prop = value.getProperty(runtime, "arrayStride");
-        result->arrayStride =
-            JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stepMode")) {
-        auto prop = value.getProperty(runtime, "stepMode");
-        result->stepMode =
-            JSIConverter<std::optional<wgpu::VertexStepMode>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "attributes")) {
-        auto prop = value.getProperty(runtime, "attributes");
-        result->attributes = JSIConverter<
-            std::vector<std::shared_ptr<GPUVertexAttribute>>>::fromJSI(runtime,
-                                                                       prop,
-                                                                       false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUVertexBufferLayout> arg) {
-    throw std::runtime_error("Invalid GPUVertexBufferLayout::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,73 +0,0 @@
-#pragma once
-
-#include <map>
-#include <memory>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "GPUVertexBufferLayout.h"
-#include "rnwgpu/api/GPUShaderModule.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUVertexState {
-  std::optional<std::vector<
-      std::variant<std::nullptr_t, std::shared_ptr<GPUVertexBufferLayout>>>>
-      buffers; // Iterable<GPUVertexBufferLayout | null>
-  std::shared_ptr<GPUShaderModule> module; // GPUShaderModule
-  std::optional<std::string> entryPoint;   // string
-  std::optional<std::map<std::string, double>>
-      constants; // Record< string, GPUPipelineConstantValue >
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexState>> {
-  static std::shared_ptr<rnwgpu::GPUVertexState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUVertexState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "buffers")) {
-        auto prop = value.getProperty(runtime, "buffers");
-        result->buffers = JSIConverter<std::optional<std::vector<std::variant<
-            std::nullptr_t, std::shared_ptr<GPUVertexBufferLayout>>>>>::
-            fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "module")) {
-        auto prop = value.getProperty(runtime, "module");
-        result->module =
-            JSIConverter<std::shared_ptr<GPUShaderModule>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "entryPoint")) {
-        auto prop = value.getProperty(runtime, "entryPoint");
-        result->entryPoint = JSIConverter<std::optional<std::string>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "constants")) {
-        auto prop = value.getProperty(runtime, "constants");
-        result->constants =
-            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUVertexState> arg) {
-    throw std::runtime_error("Invalid GPUVertexState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu