@rive-app/react-native 0.1.1-beta.0

package/nitrogen/generated/shared/c++/RiveError.hpp

@@ -0,0 +1,81 @@
+///
+/// RiveError.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `RiveErrorType` to properly resolve imports.
+namespace margelo::nitro::rive { enum class RiveErrorType; }
+
+#include <string>
+#include "RiveErrorType.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RiveError).
+   */
+  struct RiveError {
+  public:
+    std::string message     SWIFT_PRIVATE;
+    RiveErrorType type     SWIFT_PRIVATE;
+
+  public:
+    RiveError() = default;
+    explicit RiveError(std::string message, RiveErrorType type): message(message), type(type) {}
+  };
+
+} // namespace margelo::nitro::rive
+
+namespace margelo::nitro {
+
+  // C++ RiveError <> JS RiveError (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rive::RiveError> final {
+    static inline margelo::nitro::rive::RiveError fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rive::RiveError(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "message")),
+        JSIConverter<margelo::nitro::rive::RiveErrorType>::fromJSI(runtime, obj.getProperty(runtime, "type"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rive::RiveError& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "message", JSIConverter<std::string>::toJSI(runtime, arg.message));
+      obj.setProperty(runtime, "type", JSIConverter<margelo::nitro::rive::RiveErrorType>::toJSI(runtime, arg.type));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "message"))) return false;
+      if (!JSIConverter<margelo::nitro::rive::RiveErrorType>::canConvert(runtime, obj.getProperty(runtime, "type"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/RiveErrorType.hpp

@@ -0,0 +1,75 @@
+///
+/// RiveErrorType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::rive {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (RiveErrorType).
+   */
+  enum class RiveErrorType {
+    UNKNOWN      SWIFT_NAME(unknown) = 0,
+    FILENOTFOUND      SWIFT_NAME(filenotfound) = 1,
+    MALFORMEDFILE      SWIFT_NAME(malformedfile) = 2,
+    INCORRECTARTBOARDNAME      SWIFT_NAME(incorrectartboardname) = 3,
+    INCORRECTSTATEMACHINENAME      SWIFT_NAME(incorrectstatemachinename) = 4,
+    VIEWMODELINSTANCENOTFOUND      SWIFT_NAME(viewmodelinstancenotfound) = 6,
+    INCORRECTSTATEMACHINEINPUTNAME      SWIFT_NAME(incorrectstatemachineinputname) = 8,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::rive
+
+namespace margelo::nitro {
+
+  // C++ RiveErrorType <> JS RiveErrorType (enum)
+  template <>
+  struct JSIConverter<margelo::nitro::rive::RiveErrorType> final {
+    static inline margelo::nitro::rive::RiveErrorType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<margelo::nitro::rive::RiveErrorType>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::rive::RiveErrorType arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
+        return false;
+      }
+      switch (integer) {
+        case 0 /* UNKNOWN */: return true;
+        case 1 /* FILENOTFOUND */: return true;
+        case 2 /* MALFORMEDFILE */: return true;
+        case 3 /* INCORRECTARTBOARDNAME */: return true;
+        case 4 /* INCORRECTSTATEMACHINENAME */: return true;
+        case 6 /* VIEWMODELINSTANCENOTFOUND */: return true;
+        case 8 /* INCORRECTSTATEMACHINEINPUTNAME */: return true;
+        default: return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/RiveEventType.hpp

@@ -0,0 +1,62 @@
+///
+/// RiveEventType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::rive {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (RiveEventType).
+   */
+  enum class RiveEventType {
+    GENERAL      SWIFT_NAME(general) = 0,
+    OPENURL      SWIFT_NAME(openurl) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::rive
+
+namespace margelo::nitro {
+
+  // C++ RiveEventType <> JS RiveEventType (enum)
+  template <>
+  struct JSIConverter<margelo::nitro::rive::RiveEventType> final {
+    static inline margelo::nitro::rive::RiveEventType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<margelo::nitro::rive::RiveEventType>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::rive::RiveEventType arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 0 && integer <= 1;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/UnifiedRiveEvent.hpp

@@ -0,0 +1,100 @@
+///
+/// UnifiedRiveEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `RiveEventType` to properly resolve imports.
+namespace margelo::nitro::rive { enum class RiveEventType; }
+
+#include <string>
+#include "RiveEventType.hpp"
+#include <optional>
+#include <variant>
+#include <unordered_map>
+
+namespace margelo::nitro::rive {
+
+  /**
+   * A struct which can be represented as a JavaScript object (UnifiedRiveEvent).
+   */
+  struct UnifiedRiveEvent {
+  public:
+    std::string name     SWIFT_PRIVATE;
+    RiveEventType type     SWIFT_PRIVATE;
+    std::optional<double> delay     SWIFT_PRIVATE;
+    std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>> properties     SWIFT_PRIVATE;
+    std::optional<std::string> url     SWIFT_PRIVATE;
+    std::optional<std::string> target     SWIFT_PRIVATE;
+
+  public:
+    UnifiedRiveEvent() = default;
+    explicit UnifiedRiveEvent(std::string name, RiveEventType type, std::optional<double> delay, std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>> properties, std::optional<std::string> url, std::optional<std::string> target): name(name), type(type), delay(delay), properties(properties), url(url), target(target) {}
+  };
+
+} // namespace margelo::nitro::rive
+
+namespace margelo::nitro {
+
+  // C++ UnifiedRiveEvent <> JS UnifiedRiveEvent (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rive::UnifiedRiveEvent> final {
+    static inline margelo::nitro::rive::UnifiedRiveEvent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rive::UnifiedRiveEvent(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "name")),
+        JSIConverter<margelo::nitro::rive::RiveEventType>::fromJSI(runtime, obj.getProperty(runtime, "type")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "delay")),
+        JSIConverter<std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>>::fromJSI(runtime, obj.getProperty(runtime, "properties")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "url")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "target"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rive::UnifiedRiveEvent& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "name", JSIConverter<std::string>::toJSI(runtime, arg.name));
+      obj.setProperty(runtime, "type", JSIConverter<margelo::nitro::rive::RiveEventType>::toJSI(runtime, arg.type));
+      obj.setProperty(runtime, "delay", JSIConverter<std::optional<double>>::toJSI(runtime, arg.delay));
+      obj.setProperty(runtime, "properties", JSIConverter<std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>>::toJSI(runtime, arg.properties));
+      obj.setProperty(runtime, "url", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.url));
+      obj.setProperty(runtime, "target", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.target));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "name"))) return false;
+      if (!JSIConverter<margelo::nitro::rive::RiveEventType>::canConvert(runtime, obj.getProperty(runtime, "type"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "delay"))) return false;
+      if (!JSIConverter<std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>>::canConvert(runtime, obj.getProperty(runtime, "properties"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "url"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "target"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/views/HybridRiveViewComponent.cpp

@@ -0,0 +1,183 @@
+///
+/// HybridRiveViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRiveViewComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::rive::views {
+
+  extern const char HybridRiveViewComponentName[] = "RiveView";
+
+  HybridRiveViewProps::HybridRiveViewProps(const react::PropsParserContext& context,
+                                           const HybridRiveViewProps& sourceProps,
+                                           const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    artboardName([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("artboardName", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.artboardName;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.artboardName);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.artboardName: ") + exc.what());
+      }
+    }()),
+    stateMachineName([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("stateMachineName", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.stateMachineName;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.stateMachineName);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.stateMachineName: ") + exc.what());
+      }
+    }()),
+    autoPlay([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("autoPlay", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.autoPlay;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.autoPlay);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.autoPlay: ") + exc.what());
+      }
+    }()),
+    file([&]() -> CachedProp<std::shared_ptr<HybridRiveFileSpec>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("file", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.file;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::shared_ptr<HybridRiveFileSpec>>::fromRawValue(*runtime, value, sourceProps.file);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.file: ") + exc.what());
+      }
+    }()),
+    alignment([&]() -> CachedProp<std::optional<Alignment>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("alignment", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.alignment;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<Alignment>>::fromRawValue(*runtime, value, sourceProps.alignment);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.alignment: ") + exc.what());
+      }
+    }()),
+    fit([&]() -> CachedProp<std::optional<Fit>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("fit", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.fit;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<Fit>>::fromRawValue(*runtime, value, sourceProps.fit);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.fit: ") + exc.what());
+      }
+    }()),
+    layoutScaleFactor([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("layoutScaleFactor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.layoutScaleFactor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.layoutScaleFactor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.layoutScaleFactor: ") + exc.what());
+      }
+    }()),
+    dataBind([&]() -> CachedProp<std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("dataBind", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.dataBind;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>>::fromRawValue(*runtime, value, sourceProps.dataBind);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.dataBind: ") + exc.what());
+      }
+    }()),
+    onError([&]() -> CachedProp<std::function<void(const RiveError& /* error */)>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onError;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::function<void(const RiveError& /* error */)>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onError);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.onError: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridRiveViewSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridRiveViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RiveView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridRiveViewProps::HybridRiveViewProps(const HybridRiveViewProps& other):
+    react::ViewProps(),
+    artboardName(other.artboardName),
+    stateMachineName(other.stateMachineName),
+    autoPlay(other.autoPlay),
+    file(other.file),
+    alignment(other.alignment),
+    fit(other.fit),
+    layoutScaleFactor(other.layoutScaleFactor),
+    dataBind(other.dataBind),
+    onError(other.onError),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridRiveViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("artboardName"): return true;
+      case hashString("stateMachineName"): return true;
+      case hashString("autoPlay"): return true;
+      case hashString("file"): return true;
+      case hashString("alignment"): return true;
+      case hashString("fit"): return true;
+      case hashString("layoutScaleFactor"): return true;
+      case hashString("dataBind"): return true;
+      case hashString("onError"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridRiveViewComponentDescriptor::HybridRiveViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridRiveViewComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                    const std::shared_ptr<const react::Props>& props,
+                                                                                    react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridRiveViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridRiveViewComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<HybridRiveViewShadowNode&>(shadowNode);
+    const HybridRiveViewProps& props = concreteShadowNode.getConcreteProps();
+    HybridRiveViewState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::rive::views

package/nitrogen/generated/shared/c++/views/HybridRiveViewComponent.hpp

@@ -0,0 +1,124 @@
+///
+/// HybridRiveViewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <optional>
+#include <memory>
+#include "HybridRiveFileSpec.hpp"
+#include "Alignment.hpp"
+#include "Fit.hpp"
+#include "HybridViewModelInstanceSpec.hpp"
+#include "DataBindMode.hpp"
+#include "DataBindByName.hpp"
+#include <variant>
+#include "RiveError.hpp"
+#include <functional>
+#include "HybridRiveViewSpec.hpp"
+
+namespace margelo::nitro::rive::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridRiveViewComponentName[];
+
+  /**
+   * Props for the "RiveView" View.
+   */
+  class HybridRiveViewProps final: public react::ViewProps {
+  public:
+    HybridRiveViewProps() = default;
+    HybridRiveViewProps(const HybridRiveViewProps&);
+    HybridRiveViewProps(const react::PropsParserContext& context,
+                        const HybridRiveViewProps& sourceProps,
+                        const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::string>> artboardName;
+    CachedProp<std::optional<std::string>> stateMachineName;
+    CachedProp<std::optional<bool>> autoPlay;
+    CachedProp<std::shared_ptr<HybridRiveFileSpec>> file;
+    CachedProp<std::optional<Alignment>> alignment;
+    CachedProp<std::optional<Fit>> fit;
+    CachedProp<std::optional<double>> layoutScaleFactor;
+    CachedProp<std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>> dataBind;
+    CachedProp<std::function<void(const RiveError& /* error */)>> onError;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridRiveViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "RiveView" View.
+   */
+  class HybridRiveViewState final {
+  public:
+    HybridRiveViewState() = default;
+
+  public:
+    void setProps(const HybridRiveViewProps& props) { _props.emplace(props); }
+    const std::optional<HybridRiveViewProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridRiveViewState(const HybridRiveViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridRiveViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridRiveViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridRiveViewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "RiveView" View.
+   */
+  using HybridRiveViewShadowNode = react::ConcreteViewShadowNode<HybridRiveViewComponentName /* "HybridRiveView" */,
+                                                                 HybridRiveViewProps /* custom props */,
+                                                                 react::ViewEventEmitter /* default */,
+                                                                 HybridRiveViewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "RiveView" View.
+   */
+  class HybridRiveViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridRiveViewShadowNode> {
+  public:
+    HybridRiveViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridRiveViewProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "RiveView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::rive::views

package/nitrogen/generated/shared/json/RiveViewConfig.json

@@ -0,0 +1,18 @@
+{
+  "uiViewClassName": "RiveView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "artboardName": true,
+    "stateMachineName": true,
+    "autoPlay": true,
+    "file": true,
+    "alignment": true,
+    "fit": true,
+    "layoutScaleFactor": true,
+    "dataBind": true,
+    "onError": true,
+    "hybridRef": true
+  }
+}