From 8e7f1c3c482337c5617b22a6bfa5dea304d78e1e Mon Sep 17 00:00:00 2001 From: Fuad Laguda Date: Fri, 2 Oct 2026 21:15:40 +0100 Subject: [PATCH 1/2] fix(views): accept null for a removed function prop ReactProp::fromRawValue unwrapped function props with asObject() before anything checked for null. When a view had a function prop on one render and the next render omits it, React Native hands the prop over as null, so the unwrap threw 'Value is null, expected an Object' from cloneNodeWithNewProps and the commit failed. The optional converter that would have treated the value as absent was never reached, and it only knew undefined anyway. Only unwrap { f } when the value is an object, and let JSIConverter> treat null like undefined in fromJSI and canConvert. The generated setters already pass nullptr to the platform side for an empty optional. Seen through VisionCamera: followed by a rerender without that prop fails the harness test 'reconfigures when the Camera device position prop changes' on a Galaxy A14 (SM-A145F, Android 15). With this change the test passes. --- .../cpp/jsi/JSIConverter+Optional.hpp | 4 ++-- .../react-native-nitro-modules/cpp/views/ReactProp.hpp | 7 ++++++- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/packages/react-native-nitro-modules/cpp/jsi/JSIConverter+Optional.hpp b/packages/react-native-nitro-modules/cpp/jsi/JSIConverter+Optional.hpp index 93e9ae5f37..a86931fb46 100644 --- a/packages/react-native-nitro-modules/cpp/jsi/JSIConverter+Optional.hpp +++ b/packages/react-native-nitro-modules/cpp/jsi/JSIConverter+Optional.hpp @@ -23,7 +23,7 @@ using namespace facebook; template struct JSIConverter> final { static inline std::optional fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { - if (arg.isUndefined()) { + if (arg.isUndefined() || arg.isNull()) { return std::nullopt; } else { return JSIConverter::fromJSI(runtime, arg); @@ -37,7 +37,7 @@ struct JSIConverter> final { } } static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { - if (value.isUndefined()) { + if (value.isUndefined() || value.isNull()) { return true; } if (JSIConverter::canConvert(runtime, value)) { diff --git a/packages/react-native-nitro-modules/cpp/views/ReactProp.hpp b/packages/react-native-nitro-modules/cpp/views/ReactProp.hpp index ad9e4c0c08..95d9a87045 100644 --- a/packages/react-native-nitro-modules/cpp/views/ReactProp.hpp +++ b/packages/react-native-nitro-modules/cpp/views/ReactProp.hpp @@ -102,7 +102,12 @@ class ReactProp final { // React Native cannot transport functions as regular props. Nitrogen // wraps them as `{ f: function }`, so we unwrap `f` before converting // and caching the JSI value. - value = value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")); + // A function prop that was set on a previous render and is omitted on this one arrives + // as `null` (React diffs the removed prop as null), so only unwrap when there is an object; + // null/undefined fall through to the std::optional converter as "no value". + if (value.isObject()) { + value = value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")); + } } if (previousProp.equals(*runtime, value)) { From b944456ada9c5939994aed7e7cca2b0340c2646f Mon Sep 17 00:00:00 2001 From: Fuad Laguda Date: Fri, 2 Oct 2026 22:59:27 +0100 Subject: [PATCH 2/2] test(views): cover a function prop being removed on a later render TestView gains an optional someOptionalCallback prop and a hasSomeOptionalCallback() method so the harness can check what the native view received. Kotlin and Swift test views implement both. Nitrogen output regenerated. The new test renders TestView with the callback, rerenders without it and expects hasSomeOptionalCallback() to be false. On a Galaxy A14 (SM-A145F, Android 15) it fails without the ReactProp and optional converter changes and passes with them, views harness 9/9. --- .../example/__tests__/nitro.views.harness.tsx | 44 +++++++++++++++++++ .../com/margelo/nitro/test/HybridTestView.kt | 3 ++ .../ios/HybridTestView.swift | 5 +++ .../android/c++/JHybridTestViewSpec.cpp | 22 ++++++++++ .../android/c++/JHybridTestViewSpec.hpp | 3 ++ .../c++/views/JHybridTestViewStateUpdater.cpp | 5 +++ .../margelo/nitro/test/HybridTestViewSpec.kt | 18 ++++++++ .../ios/NitroTest-Swift-Cxx-Bridge.hpp | 15 +++++++ .../ios/c++/HybridTestViewSpecSwift.hpp | 15 +++++++ .../ios/c++/views/HybridTestViewComponent.mm | 6 +++ .../ios/swift/HybridTestViewSpec.swift | 2 + .../ios/swift/HybridTestViewSpec_cxx.swift | 44 +++++++++++++++++++ .../shared/c++/HybridTestViewSpec.cpp | 3 ++ .../shared/c++/HybridTestViewSpec.hpp | 3 ++ .../c++/views/HybridTestViewComponent.cpp | 2 + .../c++/views/HybridTestViewComponent.hpp | 3 ++ .../generated/shared/json/TestViewConfig.json | 1 + .../src/specs/TestView.nitro.ts | 2 + 18 files changed, 196 insertions(+) diff --git a/apps/example/__tests__/nitro.views.harness.tsx b/apps/example/__tests__/nitro.views.harness.tsx index 4de631acfa..4dcdd52a51 100644 --- a/apps/example/__tests__/nitro.views.harness.tsx +++ b/apps/example/__tests__/nitro.views.harness.tsx @@ -358,6 +358,50 @@ describe('TestView', () => { expect(view.getNativeDefaultValueSetterCallCount()).toBe(0) }) + it('accepts a function prop being removed on a later render', async () => { + const viewRef = deferred() + const stableHybridRef = callback((view: TestViewRef) => + viewRef.resolve(view) + ) + const stableSomeCallback = callback(fn()) + const renderResult = await render( + , + { timeout: RENDER_TIMEOUT } + ) + + const view = await viewRef.promise + expect(view.hasSomeOptionalCallback()).toBe(true) + + // Dropping a function prop sends `null` for it, which the native prop + // parser must treat the same as "not set". + const updatedViewRef = deferred() + await renderResult.rerender( + + updatedViewRef.resolve(updatedView) + )} + isBlue={false} + hasBeenCalled={false} + colorScheme="dark" + someCallback={stableSomeCallback} + /> + ) + + await updatedViewRef.promise + expect(view.hasSomeOptionalCallback()).toBe(false) + }) + it('only calls native setters for changed Nitro props', async () => { const viewRef = deferred() const stableHybridRef = callback((view: TestViewRef) => diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestView.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestView.kt index e3f1f6e2a9..905022791a 100644 --- a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestView.kt +++ b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestView.kt @@ -29,6 +29,7 @@ class HybridTestView( override var hasBeenCalled: Boolean = false override var colorScheme: ColorScheme = ColorScheme.LIGHT override var someCallback: () -> Unit = {} + override var someOptionalCallback: (() -> Unit)? = null override var nativeDefaultValue: Double? = 42.0 set(value) { field = value @@ -42,6 +43,8 @@ class HybridTestView( override fun getNativeDefaultValueSetterCallCount(): Double = nativeDefaultValueSetterCallCount + override fun hasSomeOptionalCallback(): Boolean = someOptionalCallback != null + override fun someMethod() { hasBeenCalled = true someCallback() diff --git a/packages/react-native-nitro-test/ios/HybridTestView.swift b/packages/react-native-nitro-test/ios/HybridTestView.swift index 56ec14ebbe..00e7a569d2 100644 --- a/packages/react-native-nitro-test/ios/HybridTestView.swift +++ b/packages/react-native-nitro-test/ios/HybridTestView.swift @@ -26,6 +26,7 @@ class HybridTestView: HybridTestViewSpec { var hasBeenCalled: Bool = false var colorScheme: ColorScheme = .light var someCallback: () -> Void = {} + var someOptionalCallback: (() -> Void)? = nil var nativeDefaultValue: Double? = 42 { didSet { nativeDefaultValueSetterCallCount += 1 @@ -45,6 +46,10 @@ class HybridTestView: HybridTestViewSpec { return nativeDefaultValueSetterCallCount } + func hasSomeOptionalCallback() throws -> Bool { + return someOptionalCallback != nil + } + func someMethod() throws { hasBeenCalled = true someCallback() diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.cpp index e80a08d8bd..9b03673311 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.cpp @@ -91,6 +91,23 @@ namespace margelo::nitro::test { static const auto method = _javaPart->javaClassStatic()->getMethod /* someCallback */)>("setSomeCallback_cxx"); method(_javaPart, JFunc_void_cxx::fromCpp(someCallback)); } + std::optional> JHybridTestViewSpec::getSomeOptionalCallback() { + static const auto method = _javaPart->javaClassStatic()->getMethod()>("getSomeOptionalCallback_cxx"); + auto __result = method(_javaPart); + return __result != nullptr ? std::make_optional([&]() -> std::function { + if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] { + auto downcast = jni::static_ref_cast(__result); + return downcast->cthis()->getFunction(); + } else { + auto __resultRef = jni::make_global(__result); + return JNICallable(std::move(__resultRef)); + } + }()) : std::nullopt; + } + void JHybridTestViewSpec::setSomeOptionalCallback(const std::optional>& someOptionalCallback) { + static const auto method = _javaPart->javaClassStatic()->getMethod /* someOptionalCallback */)>("setSomeOptionalCallback_cxx"); + method(_javaPart, someOptionalCallback.has_value() ? JFunc_void_cxx::fromCpp(someOptionalCallback.value()) : nullptr); + } std::optional JHybridTestViewSpec::getNativeDefaultValue() { static const auto method = _javaPart->javaClassStatic()->getMethod()>("getNativeDefaultValue"); auto __result = method(_javaPart); @@ -121,5 +138,10 @@ namespace margelo::nitro::test { static const auto method = _javaPart->javaClassStatic()->getMethod("someMethod"); method(_javaPart); } + bool JHybridTestViewSpec::hasSomeOptionalCallback() { + static const auto method = _javaPart->javaClassStatic()->getMethod("hasSomeOptionalCallback"); + auto __result = method(_javaPart); + return static_cast(__result); + } } // namespace margelo::nitro::test diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.hpp index 9e88cf704a..20b2e60d7a 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestViewSpec.hpp @@ -58,6 +58,8 @@ namespace margelo::nitro::test { void setColorScheme(ColorScheme colorScheme) override; std::function getSomeCallback() override; void setSomeCallback(const std::function& someCallback) override; + std::optional> getSomeOptionalCallback() override; + void setSomeOptionalCallback(const std::optional>& someOptionalCallback) override; std::optional getNativeDefaultValue() override; void setNativeDefaultValue(std::optional nativeDefaultValue) override; @@ -67,6 +69,7 @@ namespace margelo::nitro::test { double getIsBlueSetterCallCount() override; double getNativeDefaultValueSetterCallCount() override; void someMethod() override; + bool hasSomeOptionalCallback() override; private: jni::global_ref _javaPart; diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.cpp index 25fc8c7225..a500c27b3e 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.cpp @@ -73,6 +73,11 @@ void JHybridTestViewStateUpdater::updateViewProps(jni::alias_ref /* : !newProps->someCallback.hasSameValue(oldProps->someCallback)) { hybridView->setSomeCallback(newProps->someCallback.get()); } + if (oldProps == nullptr + ? newProps->someOptionalCallback.isProvided() + : !newProps->someOptionalCallback.hasSameValue(oldProps->someOptionalCallback)) { + hybridView->setSomeOptionalCallback(newProps->someOptionalCallback.get()); + } if (oldProps == nullptr ? newProps->nativeDefaultValue.isProvided() : !newProps->nativeDefaultValue.hasSameValue(oldProps->nativeDefaultValue)) { diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestViewSpec.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestViewSpec.kt index 6ad82b276b..1082a7ae2b 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestViewSpec.kt +++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestViewSpec.kt @@ -59,6 +59,20 @@ abstract class HybridTestViewSpec: HybridView() { someCallback = value } + abstract var someOptionalCallback: (() -> Unit)? + + private var someOptionalCallback_cxx: Func_void? + @Keep + @DoNotStrip + get() { + return someOptionalCallback?.let { Func_void_java(it) } + } + @Keep + @DoNotStrip + set(value) { + someOptionalCallback = value?.let { it } + } + @get:DoNotStrip @get:Keep @set:DoNotStrip @@ -81,6 +95,10 @@ abstract class HybridTestViewSpec: HybridView() { @DoNotStrip @Keep abstract fun someMethod(): Unit + + @DoNotStrip + @Keep + abstract fun hasSomeOptionalCallback(): Boolean // Default implementation of `HybridObject.toString()` override fun toString(): String { diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp index 32c14930e8..3ab3ab8b7e 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp @@ -2371,5 +2371,20 @@ namespace margelo::nitro::test::bridge::swift { inline Result_std__variant_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec___std__string__ create_Result_std__variant_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec___std__string__(const std::exception_ptr& error) noexcept { return Result, std::string>>::withError(error); } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__function_void____ = std::optional>; + inline std::optional> create_std__optional_std__function_void____(const std::function& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__function_void____(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::function get_std__optional_std__function_void____(const std::optional>& optional) noexcept { + return optional.value(); + } } // namespace margelo::nitro::test::bridge::swift diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestViewSpecSwift.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestViewSpecSwift.hpp index d2aa02b7b4..93fa1da3f1 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestViewSpecSwift.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestViewSpecSwift.hpp @@ -91,6 +91,13 @@ namespace margelo::nitro::test { inline void setSomeCallback(const std::function& someCallback) noexcept override { _swiftPart.setSomeCallback(someCallback); } + inline std::optional> getSomeOptionalCallback() noexcept override { + auto __result = _swiftPart.getSomeOptionalCallback(); + return __result; + } + inline void setSomeOptionalCallback(const std::optional>& someOptionalCallback) noexcept override { + _swiftPart.setSomeOptionalCallback(someOptionalCallback); + } inline std::optional getNativeDefaultValue() noexcept override { auto __result = _swiftPart.getNativeDefaultValue(); return __result; @@ -131,6 +138,14 @@ namespace margelo::nitro::test { std::rethrow_exception(__result.error()); } } + inline bool hasSomeOptionalCallback() override { + auto __result = _swiftPart.hasSomeOptionalCallback(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } private: NitroTest::HybridTestViewSpec_cxx _swiftPart; diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm index dcc24aaab6..9c82c0873a 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm @@ -122,6 +122,12 @@ - (void) updateProps:(const std::shared_ptr&)props : !newViewProps.someCallback.hasSameValue(oldViewProps->someCallback)) { swiftPart.setSomeCallback(newViewProps.someCallback.get()); } + // someOptionalCallback: optional + if (oldViewProps == nullptr + ? newViewProps.someOptionalCallback.isProvided() + : !newViewProps.someOptionalCallback.hasSameValue(oldViewProps->someOptionalCallback)) { + swiftPart.setSomeOptionalCallback(newViewProps.someOptionalCallback.get()); + } // nativeDefaultValue: optional if (oldViewProps == nullptr ? newViewProps.nativeDefaultValue.isProvided() diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec.swift index 3c47050d47..134eaf11dd 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec.swift @@ -14,6 +14,7 @@ public protocol HybridTestViewSpec_protocol: HybridObject, HybridView { var hasBeenCalled: Bool { get set } var colorScheme: ColorScheme { get set } var someCallback: () -> Void { get set } + var someOptionalCallback: (() -> Void)? { get set } var nativeDefaultValue: Double? { get set } // Methods @@ -21,6 +22,7 @@ public protocol HybridTestViewSpec_protocol: HybridObject, HybridView { func getIsBlueSetterCallCount() throws -> Double func getNativeDefaultValueSetterCallCount() throws -> Double func someMethod() throws -> Void + func hasSomeOptionalCallback() throws -> Bool } public extension HybridTestViewSpec_protocol { diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec_cxx.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec_cxx.swift index f914e8317e..16355a2edc 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec_cxx.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestViewSpec_cxx.swift @@ -173,6 +173,38 @@ open class HybridTestViewSpec_cxx { } } + public final var someOptionalCallback: bridge.std__optional_std__function_void____ { + @inline(__always) + get { + return { () -> bridge.std__optional_std__function_void____ in + if let __unwrappedValue = self.__implementation.someOptionalCallback { + return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in + let __closureWrapper = Func_void(__unwrappedValue) + return bridge.create_Func_void(__closureWrapper.toUnsafe()) + }()) + } else { + return .init() + } + }() + } + @inline(__always) + set { + self.__implementation.someOptionalCallback = { () -> (() -> Void)? in + if bridge.has_value_std__optional_std__function_void____(newValue) { + let __unwrapped = bridge.get_std__optional_std__function_void____(newValue) + return { () -> () -> Void in + let __wrappedFunction = bridge.wrap_Func_void(__unwrapped) + return { () -> Void in + __wrappedFunction.call() + } + }() + } else { + return nil + } + }() + } + } + public final var nativeDefaultValue: bridge.std__optional_double_ { @inline(__always) get { @@ -245,6 +277,18 @@ open class HybridTestViewSpec_cxx { } } + @inline(__always) + public final func hasSomeOptionalCallback() -> bridge.Result_bool_ { + do { + let __result = try self.__implementation.hasSomeOptionalCallback() + let __resultCpp = __result + return bridge.create_Result_bool_(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_bool_(__exceptionPtr) + } + } + public final func getView() -> UnsafeMutableRawPointer { return Unmanaged.passRetained(__implementation.view).toOpaque() } diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.cpp index 02e5d36b28..7a7935d8e0 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.cpp @@ -22,12 +22,15 @@ namespace margelo::nitro::test { prototype.registerHybridSetter("colorScheme", &HybridTestViewSpec::setColorScheme); prototype.registerHybridGetter("someCallback", &HybridTestViewSpec::getSomeCallback); prototype.registerHybridSetter("someCallback", &HybridTestViewSpec::setSomeCallback); + prototype.registerHybridGetter("someOptionalCallback", &HybridTestViewSpec::getSomeOptionalCallback); + prototype.registerHybridSetter("someOptionalCallback", &HybridTestViewSpec::setSomeOptionalCallback); prototype.registerHybridGetter("nativeDefaultValue", &HybridTestViewSpec::getNativeDefaultValue); prototype.registerHybridSetter("nativeDefaultValue", &HybridTestViewSpec::setNativeDefaultValue); prototype.registerHybridMethod("getOnDropViewCount", &HybridTestViewSpec::getOnDropViewCount); prototype.registerHybridMethod("getIsBlueSetterCallCount", &HybridTestViewSpec::getIsBlueSetterCallCount); prototype.registerHybridMethod("getNativeDefaultValueSetterCallCount", &HybridTestViewSpec::getNativeDefaultValueSetterCallCount); prototype.registerHybridMethod("someMethod", &HybridTestViewSpec::someMethod); + prototype.registerHybridMethod("hasSomeOptionalCallback", &HybridTestViewSpec::hasSomeOptionalCallback); }); } diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.hpp index 758e772bbf..9e185947ae 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestViewSpec.hpp @@ -55,6 +55,8 @@ namespace margelo::nitro::test { virtual void setColorScheme(ColorScheme colorScheme) = 0; virtual std::function getSomeCallback() = 0; virtual void setSomeCallback(const std::function& someCallback) = 0; + virtual std::optional> getSomeOptionalCallback() = 0; + virtual void setSomeOptionalCallback(const std::optional>& someOptionalCallback) = 0; virtual std::optional getNativeDefaultValue() = 0; virtual void setNativeDefaultValue(std::optional nativeDefaultValue) = 0; @@ -64,6 +66,7 @@ namespace margelo::nitro::test { virtual double getIsBlueSetterCallCount() = 0; virtual double getNativeDefaultValueSetterCallCount() = 0; virtual void someMethod() = 0; + virtual bool hasSomeOptionalCallback() = 0; protected: // Hybrid Setup diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.cpp index 75b5df68d8..8a82c1f569 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.cpp @@ -24,6 +24,7 @@ namespace margelo::nitro::test::views { hasBeenCalled(nitro::ReactProp::fromRawValue("TestView", "hasBeenCalled", rawProps, sourceProps.hasBeenCalled)), colorScheme(nitro::ReactProp::fromRawValue("TestView", "colorScheme", rawProps, sourceProps.colorScheme)), someCallback(nitro::ReactProp>::fromRawValue("TestView", "someCallback", rawProps, sourceProps.someCallback)), + someOptionalCallback(nitro::ReactProp>>::fromRawValue("TestView", "someOptionalCallback", rawProps, sourceProps.someOptionalCallback)), nativeDefaultValue(nitro::ReactProp>::fromRawValue("TestView", "nativeDefaultValue", rawProps, sourceProps.nativeDefaultValue)), hybridRef(nitro::ReactProp& /* ref */)>>>::fromRawValue("TestView", "hybridRef", rawProps, sourceProps.hybridRef)) { } @@ -33,6 +34,7 @@ namespace margelo::nitro::test::views { case hashString("hasBeenCalled"): return true; case hashString("colorScheme"): return true; case hashString("someCallback"): return true; + case hashString("someOptionalCallback"): return true; case hashString("nativeDefaultValue"): return true; case hashString("hybridRef"): return true; default: return false; diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp index 8b8ad1e566..cc09bf6b2b 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp @@ -47,6 +47,7 @@ namespace margelo::nitro::test::views { nitro::ReactProp hasBeenCalled; nitro::ReactProp colorScheme; nitro::ReactProp> someCallback; + nitro::ReactProp>> someOptionalCallback; nitro::ReactProp> nativeDefaultValue; nitro::ReactProp& /* ref */)>>> hybridRef; @@ -56,6 +57,7 @@ namespace margelo::nitro::test::views { hasBeenCalled.hasSameValue(other.hasBeenCalled) && colorScheme.hasSameValue(other.colorScheme) && someCallback.hasSameValue(other.someCallback) && + someOptionalCallback.hasSameValue(other.someOptionalCallback) && nativeDefaultValue.hasSameValue(other.nativeDefaultValue) && hybridRef.hasSameValue(other.hybridRef); } @@ -66,6 +68,7 @@ namespace margelo::nitro::test::views { hasBeenCalled.isProvided() || colorScheme.isProvided() || someCallback.isProvided() || + someOptionalCallback.isProvided() || nativeDefaultValue.isProvided() || hybridRef.isProvided(); } diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/json/TestViewConfig.json b/packages/react-native-nitro-test/nitrogen/generated/shared/json/TestViewConfig.json index eae6ee5b0a..e42cc31806 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/json/TestViewConfig.json +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/json/TestViewConfig.json @@ -8,6 +8,7 @@ "hasBeenCalled": true, "colorScheme": true, "someCallback": true, + "someOptionalCallback": true, "nativeDefaultValue": true, "hybridRef": true } diff --git a/packages/react-native-nitro-test/src/specs/TestView.nitro.ts b/packages/react-native-nitro-test/src/specs/TestView.nitro.ts index a9b52abf48..d0a183a791 100644 --- a/packages/react-native-nitro-test/src/specs/TestView.nitro.ts +++ b/packages/react-native-nitro-test/src/specs/TestView.nitro.ts @@ -11,6 +11,7 @@ export interface TestViewProps extends HybridViewProps { hasBeenCalled: boolean colorScheme: ColorScheme someCallback: () => void + someOptionalCallback?: () => void nativeDefaultValue?: number } export interface TestViewMethods extends HybridViewMethods { @@ -18,6 +19,7 @@ export interface TestViewMethods extends HybridViewMethods { getIsBlueSetterCallCount(): number getNativeDefaultValueSetterCallCount(): number someMethod(): void + hasSomeOptionalCallback(): boolean } export type TestView = HybridViewAlias