react-native-yolo 0.0.1 → 0.0.2

package/android/src/main/java/com/yolo/HybridYolo.kt

@@ -1,12 +1,27 @@
 package com.yolo
 
+import android.graphics.Color
+import android.view.View
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
 import com.margelo.nitro.yolo.HybridYoloSpec
 
-class HybridYolo: HybridYoloSpec() {    
-    override fun sum(num1: Double, num2: Double): Double {
-        return num1 + num2
-    }
-    override fun subtract(num1: Double, num2: Double): Double {
-        return num1 - num2
-    }
+@Keep
+@DoNotStrip
+class HybridYolo(val context: ThemedReactContext): HybridYoloSpec() {
+    // View
+    override val view: View = View(context)
+
+    // Props
+    private var _isRed = false
+    override var isRed: Boolean
+        get() = _isRed
+        set(value) {
+            _isRed = value
+            view.setBackgroundColor(
+                if (value) Color.RED
+                else Color.BLACK
+            )
+        }
 }

package/android/src/main/java/com/yolo/YoloPackage.kt

@@ -4,17 +4,26 @@ import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.BaseReactPackage;
-import com.margelo.nitro.yolo.YoloOnLoad;
+import com.facebook.react.uimanager.ViewManager;
+import com.margelo.nitro.yolo.*;
+import com.margelo.nitro.yolo.views.*;
 
 
 public class YoloPackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { emptyMap() }
+  
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    val viewManagers = ArrayList<ViewManager<*, *>>()
+    viewManagers.add(HybridYoloManager())
+    return viewManagers
+  }
 
   companion object {
     init {
-      YoloOnLoad.initializeNative();
+      YoloOnLoad.initializeNative()
     }
   }
 }
+

package/ios/Bridge.h

@@ -2,7 +2,7 @@
 //  Bridge.h
 //  yolo
 //
-//  Created by Khaoula-Ghalimi on 17/06/2026
+//  Created by Khaoula-Ghalimi on 20/06/2026
 //
 
 #pragma once

package/ios/HybridYolo.swift

@@ -2,13 +2,20 @@
 //  HybridYolo.swift
 //  Pods
 //
-//  Created by Khaoula-Ghalimi on 17/06/2026.
+//  Created by Khaoula-Ghalimi on 20/06/2026.
 //
 
 import Foundation
+import UIKit
 
-class HybridYolo: HybridYoloSpec {
-    func sum(num1: Double, num2: Double) throws -> Double {
-        return num1 + num2
+class HybridYolo : HybridYoloSpec {
+  // UIView
+  var view: UIView = UIView()
+
+  // Props
+  var isRed: Bool = false {
+    didSet {
+      view.backgroundColor = isRed ? .red : .black
     }
+  }
 }

package/lib/commonjs/index.js

@@ -5,5 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Yolo = void 0;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
-const Yolo = exports.Yolo = _reactNativeNitroModules.NitroModules.createHybridObject('Yolo');
+var _YoloConfig = _interopRequireDefault(require("../nitrogen/generated/shared/json/YoloConfig.json"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const Yolo = exports.Yolo = (0, _reactNativeNitroModules.getHostComponent)('Yolo', () => _YoloConfig.default);
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","Yolo","exports","NitroModules","createHybridObject"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAGO,MAAMC,IAAI,GAAAC,OAAA,CAAAD,IAAA,GACfE,qCAAY,CAACC,kBAAkB,CAAW,MAAM,CAAC","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","_YoloConfig","_interopRequireDefault","e","__esModule","default","Yolo","exports","getHostComponent","YoloConfig"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,WAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA0E,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAOnE,MAAMG,IAAI,GAAAC,OAAA,CAAAD,IAAA,GAAG,IAAAE,yCAAgB,EAClC,MAAM,EACN,MAAMC,mBACR,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -1,5 +1,6 @@
 "use strict";
 
-import { NitroModules } from 'react-native-nitro-modules';
-export const Yolo = NitroModules.createHybridObject('Yolo');
+import { getHostComponent } from 'react-native-nitro-modules';
+import YoloConfig from '../nitrogen/generated/shared/json/YoloConfig.json';
+export const Yolo = getHostComponent('Yolo', () => YoloConfig);
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","Yolo","createHybridObject"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,OAAO,MAAMC,IAAI,GACfD,YAAY,CAACE,kBAAkB,CAAW,MAAM,CAAC","ignoreList":[]}
+{"version":3,"names":["getHostComponent","YoloConfig","Yolo"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;AAAA,SAASA,gBAAgB,QAAwB,4BAA4B;AAC7E,OAAOC,UAAU,MAAM,mDAAmD;AAO1E,OAAO,MAAMC,IAAI,GAAGF,gBAAgB,CAClC,MAAM,EACN,MAAMC,UACR,CAAC","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -1,3 +1,5 @@
-import type { Yolo as YoloSpec } from './specs/yolo.nitro';
-export declare const Yolo: YoloSpec;
+import { type HybridRef } from 'react-native-nitro-modules';
+import type { YoloProps, YoloMethods } from './specs/yolo.nitro';
+export declare const Yolo: import("react-native-nitro-modules").ReactNativeView<YoloProps, YoloMethods>;
+export type YoloRef = HybridRef<YoloProps, YoloMethods>;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAE1D,eAAO,MAAM,IAAI,UACkC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE7E,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACZ,MAAM,oBAAoB,CAAA;AAG3B,eAAO,MAAM,IAAI,8EAGhB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,SAAS,EAAE,WAAW,CAAC,CAAA"}

package/lib/typescript/src/specs/yolo.nitro.d.ts

@@ -1,9 +1,11 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-export interface Yolo extends HybridObject<{
+import type { HybridView, HybridViewProps, HybridViewMethods } from 'react-native-nitro-modules';
+export interface YoloProps extends HybridViewProps {
+    isRed: boolean;
+}
+export interface YoloMethods extends HybridViewMethods {
+}
+export type Yolo = HybridView<YoloProps, YoloMethods, {
     ios: 'swift';
     android: 'kotlin';
-}> {
-    sum(num1: number, num2: number): number;
-    subtract(num1: number, num2: number): number;
-}
+}>;
 //# sourceMappingURL=yolo.nitro.d.ts.map

package/lib/typescript/src/specs/yolo.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yolo.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/yolo.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,IAAK,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAC7E,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAC7C"}
+{"version":3,"file":"yolo.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/yolo.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAEnC,MAAM,WAAW,SAAU,SAAQ,eAAe;IAC/C,KAAK,EAAE,OAAO,CAAA;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,iBAAiB;CAAG;AAEzD,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,SAAS,EAAE,WAAW,EAAE;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA"}

package/nitrogen/generated/android/Yolo+autolinking.cmake

@@ -34,8 +34,10 @@ target_sources(
   ../nitrogen/generated/android/YoloOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridYoloSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridYoloComponent.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridYoloSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridYoloStateUpdater.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/YoloOnLoad.cpp

@@ -16,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridYoloSpec.hpp"
+#include "views/JHybridYoloStateUpdater.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::yolo {
@@ -41,6 +42,7 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::yolo::JHybridYoloSpec::CxxPart::registerNatives();
+  margelo::nitro::yolo::views::JHybridYoloStateUpdater::registerNatives();
 
   // Register Nitro Hybrid Objects
   HybridObjectRegistry::registerHybridObjectConstructor(

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

@@ -41,18 +41,17 @@ namespace margelo::nitro::yolo {
   }
 
   // Properties
-  
-
-  // Methods
-  double JHybridYoloSpec::sum(double num1, double num2) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<double(double /* num1 */, double /* num2 */)>("sum");
-    auto __result = method(_javaPart, num1, num2);
-    return __result;
+  bool JHybridYoloSpec::getIsRed() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isRed");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
   }
-  double JHybridYoloSpec::subtract(double num1, double num2) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<double(double /* num1 */, double /* num2 */)>("subtract");
-    auto __result = method(_javaPart, num1, num2);
-    return __result;
+  void JHybridYoloSpec::setIsRed(bool isRed) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isRed */)>("setRed");
+    method(_javaPart, isRed);
   }
 
+  // Methods
+  
+
 } // namespace margelo::nitro::yolo

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

@@ -50,12 +50,12 @@ namespace margelo::nitro::yolo {
 
   public:
     // Properties
-    
+    bool getIsRed() override;
+    void setIsRed(bool isRed) override;
 
   public:
     // Methods
-    double sum(double num1, double num2) override;
-    double subtract(double num1, double num2) override;
+    
 
   private:
     jni::global_ref<JHybridYoloSpec::JavaPart> _javaPart;

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

@@ -0,0 +1,56 @@
+///
+/// JHybridYoloStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridYoloStateUpdater.hpp"
+#include "views/HybridYoloComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <react/fabric/StateWrapperImpl.h>
+
+namespace margelo::nitro::yolo::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridYoloState>;
+
+void JHybridYoloStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridYoloSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  std::shared_ptr<JHybridYoloSpec> hybridView = javaView->getJHybridYoloSpec();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+      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::static_pointer_cast<const ConcreteStateData>(state);
+  const HybridYoloState& data = concreteState->getData();
+  const std::shared_ptr<HybridYoloProps>& props = data.getProps();
+  if (props == nullptr) [[unlikely]] {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridYoloState's data doesn't contain any props!");
+  }
+
+  // Update all props if they are dirty
+  if (props->isRed.isDirty) {
+    hybridView->setIsRed(props->isRed.value);
+    props->isRed.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()) {
+      maybeFunc.value()(hybridView);
+    }
+    props->hybridRef.isDirty = false;
+  }
+}
+
+} // namespace margelo::nitro::yolo::views

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

@@ -0,0 +1,49 @@
+///
+/// JHybridYoloStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error Yolo 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/CoreComponentsRegistry.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridYoloSpec.hpp"
+#include "views/HybridYoloComponent.hpp"
+
+namespace margelo::nitro::yolo::views {
+
+using namespace facebook;
+
+class JHybridYoloStateUpdater final: public jni::JavaClass<JHybridYoloStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/views/HybridYoloStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridYoloSpec::JavaPart> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridYoloStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridYoloComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::yolo::views

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/HybridYoloSpec.kt

@@ -11,6 +11,7 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.HybridObject
+import com.margelo.nitro.views.HybridView
 
 /**
  * A Kotlin class representing the Yolo HybridObject.
@@ -23,18 +24,16 @@ import com.margelo.nitro.core.HybridObject
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridYoloSpec: HybridObject() {
+abstract class HybridYoloSpec: HybridView() {
   // Properties
-  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var isRed: Boolean
 
   // Methods
-  @DoNotStrip
-  @Keep
-  abstract fun sum(num1: Double, num2: Double): Double
   
-  @DoNotStrip
-  @Keep
-  abstract fun subtract(num1: Double, num2: Double): Double
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/views/HybridYoloManager.kt

@@ -0,0 +1,80 @@
+///
+/// HybridYoloManager.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.yolo.views
+
+import android.view.View
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.R.id.associated_hybrid_view_tag
+import com.margelo.nitro.views.RecyclableView
+import com.yolo.*
+
+/**
+ * Represents the React Native `ViewManager` for the "Yolo" Nitro HybridView.
+ */
+public class HybridYoloManager: SimpleViewManager<View>() {
+  init {
+    if (RecyclableView::class.java.isAssignableFrom(HybridYolo::class.java)) {
+      // Enable view recycling
+      super.setupViewRecycling()
+    }
+  }
+
+  override fun getName(): String {
+    return "Yolo"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): View {
+    val hybridView = HybridYolo(reactContext)
+    val view = hybridView.view
+    view.setTag(associated_hybrid_view_tag, hybridView)
+    return view
+  }
+
+  override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+    val hybridView = getHybridView(view)
+      ?: throw Error("Couldn't find view $view in local views table!")
+
+    // 1. Update each prop individually
+    hybridView.beforeUpdate()
+    HybridYoloStateUpdater.updateViewProps(hybridView, stateWrapper)
+    hybridView.afterUpdate()
+
+    // 2. Continue in base View props
+    return super.updateState(view, props, stateWrapper)
+  }
+
+  override fun onDropViewInstance(view: View) {
+    val hybridView = getHybridView(view)
+    hybridView?.onDropView()
+    return super.onDropViewInstance(view)
+  }
+
+  protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
+    super.prepareToRecycleView(reactContext, view)
+    val hybridView = getHybridView(view)
+      ?: return null
+
+    @Suppress("USELESS_IS_CHECK")
+    if (hybridView is RecyclableView) {
+      // Recycle in it's implementation
+      hybridView.prepareForRecycle()
+
+      // Maybe update the view if it changed
+      return hybridView.view
+    } else {
+      return null
+    }
+  }
+
+  private fun getHybridView(view: View): HybridYolo? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridYolo
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/views/HybridYoloStateUpdater.kt

@@ -0,0 +1,23 @@
+///
+/// HybridYoloStateUpdater.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.yolo.views
+
+import com.facebook.react.uimanager.StateWrapper
+import com.margelo.nitro.yolo.*
+
+internal class HybridYoloStateUpdater {
+  companion object {
+    /**
+     * Updates the props for [view] through C++.
+     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     */
+    @Suppress("KotlinJniMissingFunction")
+    @JvmStatic
+    external fun updateViewProps(view: HybridYoloSpec, state: StateWrapper)
+  }
+}

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Bridge.hpp

@@ -17,8 +17,6 @@ namespace Yolo { class HybridYoloSpec_cxx; }
 
 // Include C++ defined types
 #include "HybridYoloSpec.hpp"
-#include <NitroModules/Result.hpp>
-#include <exception>
 #include <memory>
 
 /**
@@ -38,14 +36,5 @@ namespace margelo::nitro::yolo::bridge::swift {
   // pragma MARK: std::weak_ptr<HybridYoloSpec>
   using std__weak_ptr_HybridYoloSpec_ = std::weak_ptr<HybridYoloSpec>;
   inline std__weak_ptr_HybridYoloSpec_ weakify_std__shared_ptr_HybridYoloSpec_(const std::shared_ptr<HybridYoloSpec>& strong) noexcept { return strong; }
-  
-  // pragma MARK: Result<double>
-  using Result_double_ = Result<double>;
-  inline Result_double_ create_Result_double_(double value) noexcept {
-    return Result<double>::withValue(std::move(value));
-  }
-  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
-    return Result<double>::withError(error);
-  }
 
 } // namespace margelo::nitro::yolo::bridge::swift

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Umbrella.hpp

@@ -13,8 +13,6 @@ namespace margelo::nitro::yolo { class HybridYoloSpec; }
 
 // Include C++ defined types
 #include "HybridYoloSpec.hpp"
-#include <NitroModules/Result.hpp>
-#include <exception>
 #include <memory>
 
 // C++ helpers for Swift

package/nitrogen/generated/ios/c++/HybridYoloSpecSwift.hpp

@@ -62,26 +62,16 @@ namespace margelo::nitro::yolo {
 
   public:
     // Properties
-    
+    inline bool getIsRed() noexcept override {
+      return _swiftPart.isRed();
+    }
+    inline void setIsRed(bool isRed) noexcept override {
+      _swiftPart.setIsRed(std::forward<decltype(isRed)>(isRed));
+    }
 
   public:
     // Methods
-    inline double sum(double num1, double num2) override {
-      auto __result = _swiftPart.sum(std::forward<decltype(num1)>(num1), std::forward<decltype(num2)>(num2));
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
-    inline double subtract(double num1, double num2) override {
-      auto __result = _swiftPart.subtract(std::forward<decltype(num1)>(num1), std::forward<decltype(num2)>(num2));
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
+    
 
   private:
     Yolo::HybridYoloSpec_cxx _swiftPart;

package/nitrogen/generated/ios/c++/views/HybridYoloComponent.mm

@@ -0,0 +1,122 @@
+///
+/// HybridYoloComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import "HybridYoloComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridYoloSpecSwift.hpp"
+#import "Yolo-Swift-Cxx-Umbrella.hpp"
+
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#if REACT_NATIVE_VERSION_MINOR >= 82
+#define ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+#endif
+#endif
+
+using namespace facebook;
+using namespace margelo::nitro::yolo;
+using namespace margelo::nitro::yolo::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "Yolo" HybridView.
+ */
+@interface HybridYoloComponent: RCTViewComponentView
++ (BOOL)shouldBeRecycled;
+@end
+
+@implementation HybridYoloComponent {
+  std::shared_ptr<HybridYoloSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridYoloComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridYoloComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridYoloSpec> hybridView = Yolo::YoloAutolinking::createYolo();
+    _hybridView = std::dynamic_pointer_cast<HybridYoloSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  Yolo::HybridYoloSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridYoloProps const>(props);
+  auto& newViewProps = const_cast<HybridYoloProps&>(newViewPropsConst);
+  Yolo::HybridYoloSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // isRed: boolean
+  if (newViewProps.isRed.isDirty) {
+    swiftPart.setIsRed(newViewProps.isRed.value);
+    newViewProps.isRed.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (BOOL)shouldBeRecycled {
+  return Yolo::YoloAutolinking::isYoloRecyclable();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  Yolo::HybridYoloSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.maybePrepareForRecycle();
+}
+
+#ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+- (void)invalidate {
+  Yolo::HybridYoloSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  [super invalidate];
+}
+#endif
+
+@end

package/nitrogen/generated/ios/swift/HybridYoloSpec.swift

@@ -8,13 +8,12 @@
 import NitroModules
 
 /// See ``HybridYoloSpec``
-public protocol HybridYoloSpec_protocol: HybridObject {
+public protocol HybridYoloSpec_protocol: HybridObject, HybridView {
   // Properties
-  
+  var isRed: Bool { get set }
 
   // Methods
-  func sum(num1: Double, num2: Double) throws -> Double
-  func subtract(num1: Double, num2: Double) throws -> Double
+  
 }
 
 public extension HybridYoloSpec_protocol {

package/nitrogen/generated/ios/swift/HybridYoloSpec_cxx.swift

@@ -121,30 +121,36 @@ open class HybridYoloSpec_cxx {
   }
 
   // Properties
-  
+  public final var isRed: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.isRed
+    }
+    @inline(__always)
+    set {
+      self.__implementation.isRed = newValue
+    }
+  }
 
   // Methods
-  @inline(__always)
-  public final func sum(num1: Double, num2: Double) -> bridge.Result_double_ {
-    do {
-      let __result = try self.__implementation.sum(num1: num1, num2: num2)
-      let __resultCpp = __result
-      return bridge.create_Result_double_(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_double_(__exceptionPtr)
-    }
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
   }
   
-  @inline(__always)
-  public final func subtract(num1: Double, num2: Double) -> bridge.Result_double_ {
-    do {
-      let __result = try self.__implementation.subtract(num1: num1, num2: num2)
-      let __resultCpp = __result
-      return bridge.create_Result_double_(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_double_(__exceptionPtr)
-    }
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+  
+  public final func maybePrepareForRecycle() {
+    guard let recyclable = __implementation as? any RecyclableView else { return }
+    recyclable.prepareForRecycle()
+  }
+  
+  public final func onDropView() {
+    __implementation.onDropView()
   }
 }

package/nitrogen/generated/shared/c++/HybridYoloSpec.cpp

@@ -14,8 +14,8 @@ namespace margelo::nitro::yolo {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
-      prototype.registerHybridMethod("sum", &HybridYoloSpec::sum);
-      prototype.registerHybridMethod("subtract", &HybridYoloSpec::subtract);
+      prototype.registerHybridGetter("isRed", &HybridYoloSpec::getIsRed);
+      prototype.registerHybridSetter("isRed", &HybridYoloSpec::setIsRed);
     });
   }
 

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

@@ -44,12 +44,12 @@ namespace margelo::nitro::yolo {
 
     public:
       // Properties
-      
+      virtual bool getIsRed() = 0;
+      virtual void setIsRed(bool isRed) = 0;
 
     public:
       // Methods
-      virtual double sum(double num1, double num2) = 0;
-      virtual double subtract(double num1, double num2) = 0;
+      
 
     protected:
       // Hybrid Setup

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

@@ -0,0 +1,83 @@
+///
+/// HybridYoloComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridYoloComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/PropNameIDCache.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::yolo::views {
+
+  extern const char HybridYoloComponentName[] = "Yolo";
+
+  HybridYoloProps::HybridYoloProps(const react::PropsParserContext& context,
+                                   const HybridYoloProps& sourceProps,
+                                   const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    isRed([&]() -> CachedProp<bool> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("isRed", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.isRed;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.isRed);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Yolo.isRed: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridYoloSpec>& /* 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<HybridYoloSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Yolo.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridYoloProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("isRed"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridYoloComponentDescriptor::HybridYoloComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridYoloComponentDescriptor::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 HybridYoloShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridYoloComponentDescriptor::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 = static_cast<HybridYoloShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridYoloProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridYoloProps>& props = std::const_pointer_cast<HybridYoloProps>(constProps);
+    HybridYoloState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::yolo::views

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

@@ -0,0 +1,110 @@
+///
+/// HybridYoloComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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 <memory>
+#include "HybridYoloSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::yolo::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridYoloComponentName[];
+
+  /**
+   * Props for the "Yolo" View.
+   */
+  class HybridYoloProps final: public react::ViewProps {
+  public:
+    HybridYoloProps() = default;
+    HybridYoloProps(const react::PropsParserContext& context,
+                    const HybridYoloProps& sourceProps,
+                    const react::RawProps& rawProps);
+
+  public:
+    CachedProp<bool> isRed;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridYoloSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "Yolo" View.
+   */
+  class HybridYoloState final {
+  public:
+    HybridYoloState() = default;
+    explicit HybridYoloState(const std::shared_ptr<HybridYoloProps>& props):
+      _props(props) {}
+
+  public:
+    [[nodiscard]]
+    const std::shared_ptr<HybridYoloProps>& getProps() const {
+      return _props;
+    }
+
+  public:
+#ifdef ANDROID
+  HybridYoloState(const HybridYoloState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridYoloState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridYoloState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::shared_ptr<HybridYoloProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "Yolo" View.
+   */
+  using HybridYoloShadowNode = react::ConcreteViewShadowNode<HybridYoloComponentName /* "HybridYolo" */,
+                                                             HybridYoloProps /* custom props */,
+                                                             react::ViewEventEmitter /* default */,
+                                                             HybridYoloState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "Yolo" View.
+   */
+  class HybridYoloComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridYoloShadowNode> {
+  public:
+    explicit HybridYoloComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridYoloProps`.
+     */
+    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 "Yolo" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::yolo::views

package/nitrogen/generated/shared/json/YoloConfig.json

@@ -0,0 +1,10 @@
+{
+  "uiViewClassName": "Yolo",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "isRed": true,
+    "hybridRef": true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-yolo",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "react-native-yolo is a react native package built with Nitro",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -119,4 +119,4 @@
       ]
     ]
   }
-}
+}

package/src/index.ts

@@ -1,5 +1,14 @@
-import { NitroModules } from 'react-native-nitro-modules'
-import type { Yolo as YoloSpec } from './specs/yolo.nitro'
+import { getHostComponent, type HybridRef } from 'react-native-nitro-modules'
+import YoloConfig from '../nitrogen/generated/shared/json/YoloConfig.json'
+import type {
+  YoloProps,
+  YoloMethods,
+} from './specs/yolo.nitro'
 
-export const Yolo =
-  NitroModules.createHybridObject<YoloSpec>('Yolo')
+
+export const Yolo = getHostComponent<YoloProps, YoloMethods>(
+  'Yolo',
+  () => YoloConfig
+)
+
+export type YoloRef = HybridRef<YoloProps, YoloMethods>

package/src/specs/yolo.nitro.ts

@@ -1,6 +1,13 @@
-import type { HybridObject } from 'react-native-nitro-modules'
+import type {
+  HybridView,
+  HybridViewProps,
+  HybridViewMethods,
+} from 'react-native-nitro-modules'
 
-export interface Yolo extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
-  sum(num1: number, num2: number): number
-  subtract(num1: number, num2: number): number
-}
+export interface YoloProps extends HybridViewProps {
+   isRed: boolean
+}
+
+export interface YoloMethods extends HybridViewMethods {}
+
+export type Yolo = HybridView<YoloProps, YoloMethods, { ios: 'swift', android: 'kotlin' }>