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

package/nitrogen/generated/android/c++/JRiveError.hpp

@@ -0,0 +1,63 @@
+///
+/// JRiveError.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 <fbjni/fbjni.h>
+#include "RiveError.hpp"
+
+#include "JRiveErrorType.hpp"
+#include "RiveErrorType.hpp"
+#include <string>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RiveError" and the the Kotlin data class "RiveError".
+   */
+  struct JRiveError final: public jni::JavaClass<JRiveError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/RiveError;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RiveError by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RiveError toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      static const auto fieldType = clazz->getField<JRiveErrorType>("type");
+      jni::local_ref<JRiveErrorType> type = this->getFieldValue(fieldType);
+      return RiveError(
+        message->toStdString(),
+        type->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JRiveError::javaobject> fromCpp(const RiveError& value) {
+      using JSignature = JRiveError(jni::alias_ref<jni::JString>, jni::alias_ref<JRiveErrorType>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.message),
+        JRiveErrorType::fromCpp(value.type)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/c++/JRiveErrorType.hpp

@@ -0,0 +1,74 @@
+///
+/// JRiveErrorType.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 <fbjni/fbjni.h>
+#include "RiveErrorType.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RiveErrorType" and the the Kotlin enum "RiveErrorType".
+   */
+  struct JRiveErrorType final: public jni::JavaClass<JRiveErrorType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/RiveErrorType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RiveErrorType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RiveErrorType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RiveErrorType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRiveErrorType> fromCpp(RiveErrorType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUNKNOWN = clazz->getStaticField<JRiveErrorType>("UNKNOWN");
+      static const auto fieldFILENOTFOUND = clazz->getStaticField<JRiveErrorType>("FILENOTFOUND");
+      static const auto fieldMALFORMEDFILE = clazz->getStaticField<JRiveErrorType>("MALFORMEDFILE");
+      static const auto fieldINCORRECTARTBOARDNAME = clazz->getStaticField<JRiveErrorType>("INCORRECTARTBOARDNAME");
+      static const auto fieldINCORRECTSTATEMACHINENAME = clazz->getStaticField<JRiveErrorType>("INCORRECTSTATEMACHINENAME");
+      static const auto fieldVIEWMODELINSTANCENOTFOUND = clazz->getStaticField<JRiveErrorType>("VIEWMODELINSTANCENOTFOUND");
+      static const auto fieldINCORRECTSTATEMACHINEINPUTNAME = clazz->getStaticField<JRiveErrorType>("INCORRECTSTATEMACHINEINPUTNAME");
+      
+      switch (value) {
+        case RiveErrorType::UNKNOWN:
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        case RiveErrorType::FILENOTFOUND:
+          return clazz->getStaticFieldValue(fieldFILENOTFOUND);
+        case RiveErrorType::MALFORMEDFILE:
+          return clazz->getStaticFieldValue(fieldMALFORMEDFILE);
+        case RiveErrorType::INCORRECTARTBOARDNAME:
+          return clazz->getStaticFieldValue(fieldINCORRECTARTBOARDNAME);
+        case RiveErrorType::INCORRECTSTATEMACHINENAME:
+          return clazz->getStaticFieldValue(fieldINCORRECTSTATEMACHINENAME);
+        case RiveErrorType::VIEWMODELINSTANCENOTFOUND:
+          return clazz->getStaticFieldValue(fieldVIEWMODELINSTANCENOTFOUND);
+        case RiveErrorType::INCORRECTSTATEMACHINEINPUTNAME:
+          return clazz->getStaticFieldValue(fieldINCORRECTSTATEMACHINEINPUTNAME);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/c++/JRiveEventType.hpp

@@ -0,0 +1,59 @@
+///
+/// JRiveEventType.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 <fbjni/fbjni.h>
+#include "RiveEventType.hpp"
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RiveEventType" and the the Kotlin enum "RiveEventType".
+   */
+  struct JRiveEventType final: public jni::JavaClass<JRiveEventType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/RiveEventType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RiveEventType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RiveEventType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RiveEventType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRiveEventType> fromCpp(RiveEventType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldGENERAL = clazz->getStaticField<JRiveEventType>("GENERAL");
+      static const auto fieldOPENURL = clazz->getStaticField<JRiveEventType>("OPENURL");
+      
+      switch (value) {
+        case RiveEventType::GENERAL:
+          return clazz->getStaticFieldValue(fieldGENERAL);
+        case RiveEventType::OPENURL:
+          return clazz->getStaticFieldValue(fieldOPENURL);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/c++/JUnifiedRiveEvent.hpp

@@ -0,0 +1,96 @@
+///
+/// JUnifiedRiveEvent.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 <fbjni/fbjni.h>
+#include "UnifiedRiveEvent.hpp"
+
+#include "JEventPropertiesOutput.hpp"
+#include "JRiveEventType.hpp"
+#include "RiveEventType.hpp"
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "UnifiedRiveEvent" and the the Kotlin data class "UnifiedRiveEvent".
+   */
+  struct JUnifiedRiveEvent final: public jni::JavaClass<JUnifiedRiveEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/UnifiedRiveEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct UnifiedRiveEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    UnifiedRiveEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldType = clazz->getField<JRiveEventType>("type");
+      jni::local_ref<JRiveEventType> type = this->getFieldValue(fieldType);
+      static const auto fieldDelay = clazz->getField<jni::JDouble>("delay");
+      jni::local_ref<jni::JDouble> delay = this->getFieldValue(fieldDelay);
+      static const auto fieldProperties = clazz->getField<jni::JMap<jni::JString, JEventPropertiesOutput>>("properties");
+      jni::local_ref<jni::JMap<jni::JString, JEventPropertiesOutput>> properties = this->getFieldValue(fieldProperties);
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldTarget = clazz->getField<jni::JString>("target");
+      jni::local_ref<jni::JString> target = this->getFieldValue(fieldTarget);
+      return UnifiedRiveEvent(
+        name->toStdString(),
+        type->toCpp(),
+        delay != nullptr ? std::make_optional(delay->value()) : std::nullopt,
+        properties != nullptr ? std::make_optional([&]() {
+          std::unordered_map<std::string, std::variant<bool, std::string, double>> __map;
+          __map.reserve(properties->size());
+          for (const auto& __entry : *properties) {
+            __map.emplace(__entry.first->toStdString(), __entry.second->toCpp());
+          }
+          return __map;
+        }()) : std::nullopt,
+        url != nullptr ? std::make_optional(url->toStdString()) : std::nullopt,
+        target != nullptr ? std::make_optional(target->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JUnifiedRiveEvent::javaobject> fromCpp(const UnifiedRiveEvent& value) {
+      using JSignature = JUnifiedRiveEvent(jni::alias_ref<jni::JString>, jni::alias_ref<JRiveEventType>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JMap<jni::JString, JEventPropertiesOutput>>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.name),
+        JRiveEventType::fromCpp(value.type),
+        value.delay.has_value() ? jni::JDouble::valueOf(value.delay.value()) : nullptr,
+        value.properties.has_value() ? [&]() -> jni::local_ref<jni::JMap<jni::JString, JEventPropertiesOutput>> {
+          auto __map = jni::JHashMap<jni::JString, JEventPropertiesOutput>::create(value.properties.value().size());
+          for (const auto& __entry : value.properties.value()) {
+            __map->put(jni::make_jstring(__entry.first), JEventPropertiesOutput::fromCpp(__entry.second));
+          }
+          return __map;
+        }() : nullptr,
+        value.url.has_value() ? jni::make_jstring(value.url.value()) : nullptr,
+        value.target.has_value() ? jni::make_jstring(value.target.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/c++/JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.cpp

@@ -0,0 +1,30 @@
+///
+/// JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.hpp"
+
+namespace margelo::nitro::rive {
+  /**
+   * Converts JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName to std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>
+   */
+  std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName> JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName::toCpp() const {
+    if (isInstanceOf(JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl::First::javaClassStatic())) {
+      // It's a `std::shared_ptr<HybridViewModelInstanceSpec>`
+      auto jniValue = static_cast<const JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl::First*>(this)->getValue();
+      return jniValue->cthis()->shared_cast<JHybridViewModelInstanceSpec>();
+    } else if (isInstanceOf(JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl::Second::javaClassStatic())) {
+      // It's a `DataBindMode`
+      auto jniValue = static_cast<const JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    } else if (isInstanceOf(JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl::Third::javaClassStatic())) {
+      // It's a `DataBindByName`
+      auto jniValue = static_cast<const JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl::Third*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/c++/JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.hpp

@@ -0,0 +1,90 @@
+///
+/// JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.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 <fbjni/fbjni.h>
+#include <variant>
+
+#include <memory>
+#include "HybridViewModelInstanceSpec.hpp"
+#include "DataBindMode.hpp"
+#include "DataBindByName.hpp"
+#include <variant>
+#include "JHybridViewModelInstanceSpec.hpp"
+#include "JDataBindMode.hpp"
+#include "JDataBindByName.hpp"
+#include <string>
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName".
+   */
+  class JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName: public jni::JavaClass<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName;";
+
+    static jni::local_ref<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> create_0(jni::alias_ref<JHybridViewModelInstanceSpec::javaobject> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName(jni::alias_ref<JHybridViewModelInstanceSpec::javaobject>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> create_1(jni::alias_ref<JDataBindMode> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName(jni::alias_ref<JDataBindMode>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> create_2(jni::alias_ref<JDataBindByName> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName(jni::alias_ref<JDataBindByName>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> fromCpp(const std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(std::dynamic_pointer_cast<JHybridViewModelInstanceSpec>(std::get<0>(variant))->getJavaPart());
+        case 1: return create_1(JDataBindMode::fromCpp(std::get<1>(variant)));
+        case 2: return create_2(JDataBindByName::fromCpp(std::get<2>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName> toCpp() const;
+  };
+
+  namespace JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl {
+    class First: public jni::JavaClass<First, JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName$First;";
+    
+      [[nodiscard]] jni::local_ref<JHybridViewModelInstanceSpec::javaobject> getValue() const {
+        static const auto field = javaClassStatic()->getField<JHybridViewModelInstanceSpec::javaobject>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second: public jni::JavaClass<Second, JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName$Second;";
+    
+      [[nodiscard]] jni::local_ref<JDataBindMode> getValue() const {
+        static const auto field = javaClassStatic()->getField<JDataBindMode>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Third: public jni::JavaClass<Third, JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName$Third;";
+    
+      [[nodiscard]] jni::local_ref<JDataBindByName> getValue() const {
+        static const auto field = javaClassStatic()->getField<JDataBindByName>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName_impl
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/c++/views/JHybridRiveViewStateUpdater.cpp

@@ -0,0 +1,88 @@
+///
+/// JHybridRiveViewStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridRiveViewStateUpdater.hpp"
+#include "views/HybridRiveViewComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::rive::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridRiveViewState>;
+
+void JHybridRiveViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridRiveViewSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridRiveViewSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridRiveViewState& data = concreteState->getData();
+  const std::optional<HybridRiveViewProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridRiveViewState's data doesn't contain any props!");
+  }
+  const HybridRiveViewProps& props = maybeProps.value();
+  if (props.artboardName.isDirty) {
+    view->setArtboardName(props.artboardName.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.stateMachineName.isDirty) {
+    view->setStateMachineName(props.stateMachineName.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.autoPlay.isDirty) {
+    view->setAutoPlay(props.autoPlay.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.file.isDirty) {
+    view->setFile(props.file.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.alignment.isDirty) {
+    view->setAlignment(props.alignment.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.fit.isDirty) {
+    view->setFit(props.fit.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.layoutScaleFactor.isDirty) {
+    view->setLayoutScaleFactor(props.layoutScaleFactor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.dataBind.isDirty) {
+    view->setDataBind(props.dataBind.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onError.isDirty) {
+    view->setOnError(props.onError.value);
+    // TODO: Set isDirty = false
+  }
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridRiveViewSpec> shared = javaView->cthis()->shared_cast<JHybridRiveViewSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::rive::views

package/nitrogen/generated/android/c++/views/JHybridRiveViewStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridRiveViewStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error rive was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridRiveViewSpec.hpp"
+#include "views/HybridRiveViewComponent.hpp"
+
+namespace margelo::nitro::rive::views {
+
+using namespace facebook;
+
+class JHybridRiveViewStateUpdater: public jni::JavaClass<JHybridRiveViewStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rive/views/HybridRiveViewStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridRiveViewSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridRiveViewStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridRiveViewComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::rive::views

package/nitrogen/generated/android/kotlin/com/margelo/nitro/rive/Alignment.kt

@@ -0,0 +1,28 @@
+///
+/// Alignment.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "Alignment".
+ */
+@DoNotStrip
+@Keep
+enum class Alignment(@DoNotStrip @Keep val value: Int) {
+  TOPLEFT(0),
+  TOPCENTER(1),
+  TOPRIGHT(2),
+  CENTERLEFT(3),
+  CENTER(4),
+  CENTERRIGHT(5),
+  BOTTOMLEFT(6),
+  BOTTOMCENTER(7),
+  BOTTOMRIGHT(8);
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/rive/ArtboardBy.kt

@@ -0,0 +1,44 @@
+///
+/// ArtboardBy.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "ArtboardBy".
+ */
+@DoNotStrip
+@Keep
+data class ArtboardBy(
+  @DoNotStrip
+  @Keep
+  val type: ArtboardByTypes,
+  @DoNotStrip
+  @Keep
+  val index: Double?,
+  @DoNotStrip
+  @Keep
+  val name: String?
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(type: ArtboardByTypes, index: Double?, name: String?): ArtboardBy {
+      return ArtboardBy(type, index, name)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/rive/ArtboardByTypes.kt

@@ -0,0 +1,21 @@
+///
+/// ArtboardByTypes.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "ArtboardByTypes".
+ */
+@DoNotStrip
+@Keep
+enum class ArtboardByTypes(@DoNotStrip @Keep val value: Int) {
+  INDEX(0),
+  NAME(1);
+}