nitrogen 0.36.5 → 0.37.0-beta.0

package/lib/syntax/createType.js

@@ -45,6 +45,15 @@ function getFunctionCallSignature(func) {
     }
     return callSignature;
 }
+/**
+ * Whether the given type is optional (`T | undefined`) or not.
+ *
+ * Note that `null` is a separate type in Nitro (`NullType`) - only `undefined`
+ * (or a `?`) makes a type optional.
+ */
+function isOptionalType(type) {
+    return type.getUnionTypes().some((t) => t.isUndefined());
+}
 function removeDuplicates(types) {
     return types.filter((t1, index, array) => {
         const firstIndexOfType = array.findIndex((t2) => t1.getCode('c++') === t2.getCode('c++'));
@@ -185,7 +194,7 @@ export function createType(language, type, isOptional, typeNode) {
         }
         else if (type.isArray()) {
             const arrayElementType = type.getArrayElementTypeOrThrow();
-            const elementType = createType(language, arrayElementType, false);
+            const elementType = createType(language, arrayElementType, isOptionalType(arrayElementType));
             return new ArrayType(elementType);
         }
         else if (type.isTuple()) {
@@ -198,10 +207,7 @@ export function createType(language, type, isOptional, typeNode) {
             // It's a function!
             const callSignature = getFunctionCallSignature(type);
             const funcReturnType = callSignature.getReturnType();
-            const isReturnOptional = funcReturnType
-                .getUnionTypes()
-                .some((t) => t.isUndefined());
-            const returnType = createType(language, funcReturnType, isReturnOptional);
+            const returnType = createType(language, funcReturnType, isOptionalType(funcReturnType));
             const parameters = callSignature.getParameters().map((p) => {
                 const declaration = p.getValueDeclarationOrThrow();
                 const parameterType = p.getTypeAtLocation(declaration);
@@ -214,17 +220,14 @@ export function createType(language, type, isOptional, typeNode) {
         else if (isPromise(type)) {
             // It's a Promise!
             const [promiseResolvingType] = getArguments(type, 'Promise', 1);
-            const isResolvingOptional = promiseResolvingType
-                .getUnionTypes()
-                .some((t) => t.isUndefined());
-            const resolvingType = createType(language, promiseResolvingType, isResolvingOptional);
+            const resolvingType = createType(language, promiseResolvingType, isOptionalType(promiseResolvingType));
             return new PromiseType(resolvingType);
         }
         else if (isRecord(type)) {
             // Record<K, V> -> unordered_map<K, V>
             const [keyTypeT, valueTypeT] = getArguments(type, 'Record', 2);
             const keyType = createType(language, keyTypeT, false);
-            const valueType = createType(language, valueTypeT, false);
+            const valueType = createType(language, valueTypeT, isOptionalType(valueTypeT));
             return new RecordType(keyType, valueType);
         }
         else if (isArrayBuffer(type)) {

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -440,6 +440,13 @@ export class KotlinCxxBridgedType {
     }
     dereferenceToJObject(parameterName) {
         switch (this.type.kind) {
+            // an optional bridges to a (possibly `nullptr`) ref of its wrapping type,
+            // so it needs to be dereferenced the same way as the type it wraps.
+            case 'optional': {
+                const optional = getTypeAs(this.type, OptionalType);
+                const bridge = new KotlinCxxBridgedType(optional.wrappingType);
+                return bridge.dereferenceToJObject(parameterName);
+            }
             // any jni::HybridClass needs to be dereferenced to jobject with .get()
             case 'array-buffer':
             case 'function':

package/lib/views/CppHybridViewComponent.js

@@ -1,5 +1,5 @@
 import { createIndentation, indent } from '../utils.js';
-import { createFileMetadataString, escapeCppName, isFunction, isNotDuplicate, } from '../syntax/helpers.js';
+import { createFileMetadataString, escapeCppName, isNotDuplicate, } from '../syntax/helpers.js';
 import { getHybridObjectName } from '../syntax/getHybridObjectName.js';
 import { includeHeader } from '../syntax/c++/includeNitroHeader.js';
 import { createHostComponentJs } from './createHostComponentJs.js';
@@ -36,8 +36,16 @@ export function createViewComponentShadowNodeFiles(spec) {
     const { propsClassName, stateClassName, nameVariable, shadowNodeClassName, descriptorClassName, component, } = getViewComponentNames(spec);
     const namespace = spec.config.getCxxNamespace('c++', 'views');
     const props = [...spec.properties, getHybridRefProperty(spec)];
-    const properties = props.map((p) => `CachedProp<${p.type.getCode('c++')}> ${escapeCppName(p.name)};`);
-    const cases = props.map((p) => `case hashString("${p.name}"): return true;`);
+    const properties = props.map((p) => `nitro::CachedProp<${p.type.getCode('c++')}> ${escapeCppName(p.name)};`);
+    const filterCases = props.map((prop) => `case hashString("${prop.name}"): return true;`);
+    const comparisons = props.map((prop) => {
+        const name = escapeCppName(prop.name);
+        return `${name}.hasSameValue(other.${name})`;
+    });
+    const providedChecks = props.map((prop) => {
+        const name = escapeCppName(prop.name);
+        return `${name}.isProvided()`;
+    });
     const includes = props
         .flatMap((p) => p.getRequiredImports('c++').map((i) => includeHeader(i, true)))
         .filter(isNotDuplicate);
@@ -48,14 +56,15 @@ ${createFileMetadataString(`${component}.hpp`)}
 
 #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 <NitroModules/ViewComponentDescriptor.hpp>
+#include <NitroModules/ViewPropsHolderState.hpp>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+
+#include <string>
 
 ${includes.join('\n')}
 
@@ -81,6 +90,16 @@ namespace ${namespace} {
   public:
     ${indent(properties.join('\n'), '    ')}
 
+    [[nodiscard]]
+    bool hasSameProps(const ${propsClassName}& other) const noexcept {
+      return ${comparisons.join(' &&\n             ')};
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return ${providedChecks.join(' ||\n             ')};
+    }
+
   private:
     static bool filterObjectKeys(const std::string& propName);
   };
@@ -88,32 +107,7 @@ namespace ${namespace} {
   /**
    * State for the "${spec.name}" View.
    */
-  class ${stateClassName} final {
-  public:
-    ${stateClassName}() = default;
-    explicit ${stateClassName}(const std::shared_ptr<${propsClassName}>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<${propsClassName}>& getProps() const {
-      return _props;
-    }
-
-  public:
-#ifdef ANDROID
-  ${stateClassName}(const ${stateClassName}& /* previousState */, folly::dynamic /* data */) {}
-  folly::dynamic getDynamic() const {
-    throw std::runtime_error("${stateClassName} does not support folly!");
-  }
-  react::MapBuffer getMapBuffer() const {
-    throw std::runtime_error("${stateClassName} does not support MapBuffer!");
-  };
-#endif
-
-  private:
-    std::shared_ptr<${propsClassName}> _props;
-  };
+  using ${stateClassName} = nitro::ViewPropsHolderState<${propsClassName}>;
 
   /**
    * The Shadow Node for the "${spec.name}" View.
@@ -126,74 +120,33 @@ namespace ${namespace} {
   /**
    * The Component Descriptor for the "${spec.name}" View.
    */
-  class ${descriptorClassName} final: public react::ConcreteComponentDescriptor<${shadowNodeClassName}> {
-  public:
-    explicit ${descriptorClassName}(const react::ComponentDescriptorParameters& parameters);
-
-  public:
-    /**
-     * A faster path for cloning props - reuses the caching logic from \`${propsClassName}\`.
-     */
-    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
-  };
+  using ${descriptorClassName} = nitro::ViewComponentDescriptor<${shadowNodeClassName}>;
 
   /* The actual view for "${spec.name}" needs to be implemented in platform-specific code. */
 
 } // namespace ${namespace}
 `.trim();
-    // .cpp code
     const propInitializers = [
         'react::ViewProps(context, sourceProps, rawProps, filterObjectKeys)',
+        ...props.map((prop) => {
+            const name = escapeCppName(prop.name);
+            const type = prop.type.getCode('c++');
+            return `${name}(nitro::CachedProp<${type}>::fromRawValue("${spec.name}", "${prop.name}", rawProps, sourceProps.${name}))`;
+        }),
     ];
-    const propCopyInitializers = ['react::ViewProps()'];
-    for (const prop of props) {
-        const name = escapeCppName(prop.name);
-        const type = prop.type.getCode('c++');
-        let valueConversion = `value`;
-        if (isFunction(prop.type)) {
-            // Due to a React limitation, functions cannot be passed to native directly,
-            // because RN converts them to booleans (`true`). Nitro knows this and just
-            // wraps functions as objects - the original function is stored in `f`.
-            valueConversion = `value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f"))`;
-        }
-        propInitializers.push(`
-${name}([&]() -> CachedProp<${type}> {
-  try {
-    const react::RawValue* rawValue = rawProps.at("${prop.name}", nullptr, nullptr);
-    if (rawValue == nullptr) return sourceProps.${name};
-    const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-    return CachedProp<${type}>::fromRawValue(*runtime, ${valueConversion}, sourceProps.${name});
-  } catch (const std::exception& exc) {
-    throw std::runtime_error(std::string("${spec.name}.${prop.name}: ") + exc.what());
-  }
-}())`.trim());
-        propCopyInitializers.push(`${name}(other.${name})`);
-    }
     const ctorIndent = createIndentation(propsClassName.length * 2);
-    const descriptorIndent = createIndentation(descriptorClassName.length);
     const componentCode = `
 ${createFileMetadataString(`${component}.cpp`)}
 
 #include "${component}.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>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
 
 namespace ${namespace} {
 
+  using namespace facebook;
+
   extern const char ${nameVariable}[] = "${T}";
 
   ${propsClassName}::${propsClassName}(const react::PropsParserContext& context,
@@ -203,36 +156,11 @@ namespace ${namespace} {
 
   bool ${propsClassName}::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
-      ${indent(cases.join('\n'), '      ')}
+      ${indent(filterCases.join('\n'), '      ')}
       default: return false;
     }
   }
 
-  ${descriptorClassName}::${descriptorClassName}(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  std::shared_ptr<const react::Props> ${descriptorClassName}::cloneProps(const react::PropsParserContext& context,
-                                      ${descriptorIndent}             const std::shared_ptr<const react::Props>& props,
-                                      ${descriptorIndent}             react::RawProps rawProps) const {
-    // 1. Prepare raw props parser
-    rawProps.parse(rawPropsParser_);
-    // 2. Copy props with Nitro's cached copy constructor
-    return ${shadowNodeClassName}::Props(context, /* & */ rawProps, props);
-  }
-
-#ifdef ANDROID
-  void ${descriptorClassName}::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<${shadowNodeClassName}&>(shadowNode);
-    const std::shared_ptr<const ${propsClassName}>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<${propsClassName}>& props = std::const_pointer_cast<${propsClassName}>(constProps);
-    ${stateClassName} state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace ${namespace}
 `.trim();
     const files = [

package/lib/views/kotlin/KotlinHybridViewManager.js

@@ -34,6 +34,14 @@ import ${javaNamespace}.*
  * Represents the React Native \`ViewManager\` for the "${spec.name}" Nitro HybridView.
  */
 public class ${manager}: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: ${viewImplementation},
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(${viewImplementation}::class.java)) {
       // Enable view recycling
@@ -48,33 +56,41 @@ public class ${manager}: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = ${viewImplementation}(reactContext)
     val view = hybridView.view
-    view.setTag(associated_hybrid_view_tag, hybridView)
+    view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
     return view
   }
 
   override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
-    val hybridView = getHybridView(view)
+    val holder = getHybridViewHolder(view)
       ?: throw Error("Couldn't find view $view in local views table!")
+    val hybridView = holder.hybridView
+    val oldState = holder.lastState
+    val newState = stateWrapper
 
     // 1. Update each prop individually
     hybridView.beforeUpdate()
-    ${stateUpdaterName}.updateViewProps(hybridView, stateWrapper)
+    ${stateUpdaterName}.updateViewProps(hybridView, newState, oldState)
     hybridView.afterUpdate()
+    holder.lastState = newState
 
     // 2. Continue in base View props
-    return super.updateState(view, props, stateWrapper)
+    return super.updateState(view, props, newState)
   }
 
   override fun onDropViewInstance(view: View) {
-    val hybridView = getHybridView(view)
-    hybridView?.onDropView()
+    val holder = getHybridViewHolder(view)
+    holder?.lastState = null
+    holder?.hybridView?.onDropView()
     return super.onDropViewInstance(view)
   }
 
   protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
-    super.prepareToRecycleView(reactContext, view)
-    val hybridView = getHybridView(view)
+    val preparedView = super.prepareToRecycleView(reactContext, view)
+      ?: return null
+    val holder = getHybridViewHolder(preparedView)
       ?: return null
+    val hybridView = holder.hybridView
+    holder.lastState = null
 
     @Suppress("USELESS_IS_CHECK")
     if (hybridView is RecyclableView) {
@@ -88,8 +104,8 @@ public class ${manager}: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): ${viewImplementation}? {
-    return view.getTag(associated_hybrid_view_tag) as? ${viewImplementation}
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }
   `.trim();
@@ -105,11 +121,11 @@ internal class ${stateUpdaterName} {
   companion object {
     /**
      * Updates the props for [view] through C++.
-     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     * The [newState] prop is expected to contain [view]'s props as wrapped Fabric state.
      */
     @Suppress("KotlinJniMissingFunction")
     @JvmStatic
-    external fun updateViewProps(view: ${HybridTSpec}, state: StateWrapper)
+    external fun updateViewProps(view: ${HybridTSpec}, newState: StateWrapper, oldState: StateWrapper?)
   }
 }
   `.trim();
@@ -143,7 +159,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<${JHybridTSpec}::JavaPart> view,
-                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const ${propsClassName}> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {
@@ -164,9 +185,10 @@ public:
         const name = escapeCppName(p.name);
         const setter = p.getSetterName('other');
         return `
-if (props->${name}.isDirty) {
-  hybridView->${setter}(props->${name}.value);
-  props->${name}.isDirty = false;
+if (oldProps == nullptr
+      ? newProps->${name}.isProvided()
+      : !newProps->${name}.hasSameValue(oldProps->${name})) {
+  hybridView->${setter}(newProps->${name}.get());
 }
     `.trim();
     });
@@ -183,38 +205,55 @@ namespace ${cxxNamespace} {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<${stateClassName}>;
 
-void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<${JHybridTSpec}::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<${JHybridTSpec}> hybridView = javaView->get${JHybridTSpec}();
-
+std::shared_ptr<const ${propsClassName}> J${stateUpdaterName}::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
   // 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");
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
   }
-  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 ${stateClassName}& data = concreteState->getData();
-  const std::shared_ptr<${propsClassName}>& props = data.getProps();
+  const std::shared_ptr<const ${propsClassName}>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("${stateClassName}'s data doesn't contain any props!");
   }
+  return props;
+}
+
+void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<${JHybridTSpec}::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<${JHybridTSpec}> hybridView = javaView->get${JHybridTSpec}();
+  std::shared_ptr<const ${propsClassName}> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const ${propsClassName}> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
+  }
 
-  // Update all props if they are dirty
+  // Update only props that differ from the previous State snapshot.
   ${indent(propsUpdaterCalls.join('\n'), '  ')}
 
   // Update hybridRef if it changed
-  if (props->hybridRef.isDirty) {
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
     // hybridRef changed - call it with new this
-    const auto& maybeFunc = props->hybridRef.value;
+    const auto& maybeFunc = newProps->hybridRef.get();
     if (maybeFunc.has_value()) {
       maybeFunc.value()(hybridView);
     }
-    props->hybridRef.isDirty = false;
   }
 }
 

package/lib/views/swift/SwiftHybridViewManager.js

@@ -10,7 +10,7 @@ export function createSwiftHybridViewManager(spec) {
     const namespace = spec.config.getCxxNamespace('c++');
     const swiftNamespace = spec.config.getIosModuleName();
     const { HybridTSpec, HybridTSpecSwift, HybridTSpecCxx } = getHybridObjectName(spec.name);
-    const { component, descriptorClassName, propsClassName } = getViewComponentNames(spec);
+    const { component, descriptorClassName, propsClassName, shadowNodeClassName, } = getViewComponentNames(spec);
     const implementation = spec.config.getIosAutolinkedImplementation(spec.name);
     if (implementation?.language !== 'swift') {
         throw new Error(`Cannot create Swift HybridView ViewManager for ${spec.name} - it must be autolinked with a Swift iOS implementation in nitro.json!`);
@@ -19,12 +19,13 @@ export function createSwiftHybridViewManager(spec) {
         const name = escapeCppName(p.name);
         const setter = p.getSetterName('swift');
         const bridge = new SwiftCxxBridgedType(p.type, false);
-        const parse = bridge.parseFromCppToSwift(`newViewProps.${name}.value`, 'c++');
+        const parse = bridge.parseFromCppToSwift(`newViewProps.${name}.get()`, 'c++');
         return `
 // ${p.jsSignature}
-if (newViewProps.${name}.isDirty) {
+if (oldViewProps == nullptr
+      ? newViewProps.${name}.isProvided()
+      : !newViewProps.${name}.hasSameValue(oldViewProps->${name})) {
   swiftPart.${setter}(${indent(parse, '  ')});
-  newViewProps.${name}.isDirty = false;
 }
 `.trim();
     });
@@ -63,6 +64,7 @@ using namespace ${namespace}::views;
 
 @implementation ${component} {
   std::shared_ptr<${HybridTSpecSwift}> _hybridView;
+  BOOL _didDropView;
 }
 
 + (void) load {
@@ -76,6 +78,7 @@ using namespace ${namespace}::views;
 
 - (instancetype) init {
   if (self = [super init]) {
+    _props = ${shadowNodeClassName}::defaultSharedProps();
     std::shared_ptr<${HybridTSpec}> hybridView = ${getHybridObjectConstructorCall(spec.name)}
     _hybridView = std::dynamic_pointer_cast<${HybridTSpecSwift}>(hybridView);
     [self updateView];
@@ -95,31 +98,50 @@ using namespace ${namespace}::views;
   [self setContentView:view];
 }
 
+- (void) notifyOnDropView {
+  // A recycled component can later be invalidated. Notify only once per mount.
+  if (_didDropView) {
+    return;
+  }
+  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  _didDropView = YES;
+}
+
 - (void) updateProps:(const std::shared_ptr<const react::Props>&)props
             oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // A props update marks a newly mounted or still-active component.
+  _didDropView = NO;
+
   // 1. Downcast props
-  const auto& newViewPropsConst = *std::static_pointer_cast<${propsClassName} const>(props);
-  auto& newViewProps = const_cast<${propsClassName}&>(newViewPropsConst);
+  const auto& newViewProps = *std::static_pointer_cast<const ${propsClassName}>(props);
+  const auto* oldViewProps = static_cast<const ${propsClassName}*>(oldProps.get());
   ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
 
-  // 2. Update each prop individually
-  swiftPart.beforeUpdate();
-
-  ${indent(propAssignments.join('\n'), '  ')}
-
-  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);
+  // 2. Update only props that differ from the previous Props snapshot.
+  const bool hasTransactionPropChanges = oldViewProps == nullptr
+      ? newViewProps.hasAnyProvidedProps()
+      : !newViewProps.hasSameProps(*oldViewProps);
+  if (hasTransactionPropChanges) {
+    swiftPart.beforeUpdate();
+
+    ${indent(propAssignments.join('\n'), '    ')}
+
+    // Update hybridRef if it changed
+    if (oldViewProps == nullptr
+          ? newViewProps.hybridRef.isProvided()
+          : !newViewProps.hybridRef.hasSameValue(oldViewProps->hybridRef)) {
+      // hybridRef changed - call it with new this
+      const auto& maybeFunc = newViewProps.hybridRef.get();
+      if (maybeFunc.has_value()) {
+        maybeFunc.value()(_hybridView);
+      }
     }
-    newViewProps.hybridRef.isDirty = false;
+
+    swiftPart.afterUpdate();
   }
 
-  // 4. Continue in base class
+  // 3. Continue in base class
   [super updateProps:props oldProps:oldProps];
 }
 
@@ -128,6 +150,7 @@ using namespace ${namespace}::views;
 }
 
 - (void)prepareForRecycle {
+  [self notifyOnDropView];
   [super prepareForRecycle];
   ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
   swiftPart.maybePrepareForRecycle();
@@ -135,8 +158,7 @@ using namespace ${namespace}::views;
 
 #ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
 - (void)invalidate {
-  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
-  swiftPart.onDropView();
+  [self notifyOnDropView];
   [super invalidate];
 }
 #endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.36.5",
+  "version": "0.37.0-beta.0",
   "description": "Code generator for React Native Nitro Modules that turns TypeScript specs into C++, Swift, and Kotlin bindings.",
   "main": "lib/index",
   "types": "lib/index.d.ts",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "react-native-nitro-modules": "^0.36.5",
+    "react-native-nitro-modules": "^0.37.0-beta.0",
     "ts-morph": "^28.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.4.3"

package/src/syntax/createType.ts

@@ -69,6 +69,16 @@ function getFunctionCallSignature(func: TSMorphType): Signature {
   return callSignature
 }
 
+/**
+ * Whether the given type is optional (`T | undefined`) or not.
+ *
+ * Note that `null` is a separate type in Nitro (`NullType`) - only `undefined`
+ * (or a `?`) makes a type optional.
+ */
+function isOptionalType(type: TSMorphType): boolean {
+  return type.getUnionTypes().some((t) => t.isUndefined())
+}
+
 function removeDuplicates(types: Type[]): Type[] {
   return types.filter((t1, index, array) => {
     const firstIndexOfType = array.findIndex(
@@ -269,7 +279,11 @@ export function createType(
       return new VoidType()
     } else if (type.isArray()) {
       const arrayElementType = type.getArrayElementTypeOrThrow()
-      const elementType = createType(language, arrayElementType, false)
+      const elementType = createType(
+        language,
+        arrayElementType,
+        isOptionalType(arrayElementType)
+      )
       return new ArrayType(elementType)
     } else if (type.isTuple()) {
       const itemTypes = type
@@ -280,10 +294,11 @@ export function createType(
       // It's a function!
       const callSignature = getFunctionCallSignature(type)
       const funcReturnType = callSignature.getReturnType()
-      const isReturnOptional = funcReturnType
-        .getUnionTypes()
-        .some((t) => t.isUndefined())
-      const returnType = createType(language, funcReturnType, isReturnOptional)
+      const returnType = createType(
+        language,
+        funcReturnType,
+        isOptionalType(funcReturnType)
+      )
       const parameters = callSignature.getParameters().map((p) => {
         const declaration = p.getValueDeclarationOrThrow()
         const parameterType = p.getTypeAtLocation(declaration)
@@ -295,20 +310,21 @@ export function createType(
     } else if (isPromise(type)) {
       // It's a Promise!
       const [promiseResolvingType] = getArguments(type, 'Promise', 1)
-      const isResolvingOptional = promiseResolvingType
-        .getUnionTypes()
-        .some((t) => t.isUndefined())
       const resolvingType = createType(
         language,
         promiseResolvingType,
-        isResolvingOptional
+        isOptionalType(promiseResolvingType)
       )
       return new PromiseType(resolvingType)
     } else if (isRecord(type)) {
       // Record<K, V> -> unordered_map<K, V>
       const [keyTypeT, valueTypeT] = getArguments(type, 'Record', 2)
       const keyType = createType(language, keyTypeT, false)
-      const valueType = createType(language, valueTypeT, false)
+      const valueType = createType(
+        language,
+        valueTypeT,
+        isOptionalType(valueTypeT)
+      )
       return new RecordType(keyType, valueType)
     } else if (isArrayBuffer(type)) {
       // ArrayBuffer

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -469,6 +469,13 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
 
   dereferenceToJObject(parameterName: string): string {
     switch (this.type.kind) {
+      // an optional bridges to a (possibly `nullptr`) ref of its wrapping type,
+      // so it needs to be dereferenced the same way as the type it wraps.
+      case 'optional': {
+        const optional = getTypeAs(this.type, OptionalType)
+        const bridge = new KotlinCxxBridgedType(optional.wrappingType)
+        return bridge.dereferenceToJObject(parameterName)
+      }
       // any jni::HybridClass needs to be dereferenced to jobject with .get()
       case 'array-buffer':
       case 'function':

package/src/views/CppHybridViewComponent.ts

@@ -4,7 +4,6 @@ import { createIndentation, indent } from '../utils.js'
 import {
   createFileMetadataString,
   escapeCppName,
-  isFunction,
   isNotDuplicate,
 } from '../syntax/helpers.js'
 import { getHybridObjectName } from '../syntax/getHybridObjectName.js'
@@ -73,9 +72,20 @@ export function createViewComponentShadowNodeFiles(
 
   const props = [...spec.properties, getHybridRefProperty(spec)]
   const properties = props.map(
-    (p) => `CachedProp<${p.type.getCode('c++')}> ${escapeCppName(p.name)};`
+    (p) =>
+      `nitro::CachedProp<${p.type.getCode('c++')}> ${escapeCppName(p.name)};`
   )
-  const cases = props.map((p) => `case hashString("${p.name}"): return true;`)
+  const filterCases = props.map(
+    (prop) => `case hashString("${prop.name}"): return true;`
+  )
+  const comparisons = props.map((prop) => {
+    const name = escapeCppName(prop.name)
+    return `${name}.hasSameValue(other.${name})`
+  })
+  const providedChecks = props.map((prop) => {
+    const name = escapeCppName(prop.name)
+    return `${name}.isProvided()`
+  })
   const includes = props
     .flatMap((p) =>
       p.getRequiredImports('c++').map((i) => includeHeader(i, true))
@@ -89,14 +99,15 @@ ${createFileMetadataString(`${component}.hpp`)}
 
 #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 <NitroModules/ViewComponentDescriptor.hpp>
+#include <NitroModules/ViewPropsHolderState.hpp>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+
+#include <string>
 
 ${includes.join('\n')}
 
@@ -122,6 +133,16 @@ namespace ${namespace} {
   public:
     ${indent(properties.join('\n'), '    ')}
 
+    [[nodiscard]]
+    bool hasSameProps(const ${propsClassName}& other) const noexcept {
+      return ${comparisons.join(' &&\n             ')};
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return ${providedChecks.join(' ||\n             ')};
+    }
+
   private:
     static bool filterObjectKeys(const std::string& propName);
   };
@@ -129,32 +150,7 @@ namespace ${namespace} {
   /**
    * State for the "${spec.name}" View.
    */
-  class ${stateClassName} final {
-  public:
-    ${stateClassName}() = default;
-    explicit ${stateClassName}(const std::shared_ptr<${propsClassName}>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<${propsClassName}>& getProps() const {
-      return _props;
-    }
-
-  public:
-#ifdef ANDROID
-  ${stateClassName}(const ${stateClassName}& /* previousState */, folly::dynamic /* data */) {}
-  folly::dynamic getDynamic() const {
-    throw std::runtime_error("${stateClassName} does not support folly!");
-  }
-  react::MapBuffer getMapBuffer() const {
-    throw std::runtime_error("${stateClassName} does not support MapBuffer!");
-  };
-#endif
-
-  private:
-    std::shared_ptr<${propsClassName}> _props;
-  };
+  using ${stateClassName} = nitro::ViewPropsHolderState<${propsClassName}>;
 
   /**
    * The Shadow Node for the "${spec.name}" View.
@@ -167,80 +163,34 @@ namespace ${namespace} {
   /**
    * The Component Descriptor for the "${spec.name}" View.
    */
-  class ${descriptorClassName} final: public react::ConcreteComponentDescriptor<${shadowNodeClassName}> {
-  public:
-    explicit ${descriptorClassName}(const react::ComponentDescriptorParameters& parameters);
-
-  public:
-    /**
-     * A faster path for cloning props - reuses the caching logic from \`${propsClassName}\`.
-     */
-    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
-  };
+  using ${descriptorClassName} = nitro::ViewComponentDescriptor<${shadowNodeClassName}>;
 
   /* The actual view for "${spec.name}" needs to be implemented in platform-specific code. */
 
 } // namespace ${namespace}
 `.trim()
 
-  // .cpp code
   const propInitializers = [
     'react::ViewProps(context, sourceProps, rawProps, filterObjectKeys)',
+    ...props.map((prop) => {
+      const name = escapeCppName(prop.name)
+      const type = prop.type.getCode('c++')
+      return `${name}(nitro::CachedProp<${type}>::fromRawValue("${spec.name}", "${prop.name}", rawProps, sourceProps.${name}))`
+    }),
   ]
-  const propCopyInitializers = ['react::ViewProps()']
-  for (const prop of props) {
-    const name = escapeCppName(prop.name)
-    const type = prop.type.getCode('c++')
-
-    let valueConversion = `value`
-    if (isFunction(prop.type)) {
-      // Due to a React limitation, functions cannot be passed to native directly,
-      // because RN converts them to booleans (`true`). Nitro knows this and just
-      // wraps functions as objects - the original function is stored in `f`.
-      valueConversion = `value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f"))`
-    }
-
-    propInitializers.push(
-      `
-${name}([&]() -> CachedProp<${type}> {
-  try {
-    const react::RawValue* rawValue = rawProps.at("${prop.name}", nullptr, nullptr);
-    if (rawValue == nullptr) return sourceProps.${name};
-    const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-    return CachedProp<${type}>::fromRawValue(*runtime, ${valueConversion}, sourceProps.${name});
-  } catch (const std::exception& exc) {
-    throw std::runtime_error(std::string("${spec.name}.${prop.name}: ") + exc.what());
-  }
-}())`.trim()
-    )
-    propCopyInitializers.push(`${name}(other.${name})`)
-  }
-
   const ctorIndent = createIndentation(propsClassName.length * 2)
-  const descriptorIndent = createIndentation(descriptorClassName.length)
   const componentCode = `
 ${createFileMetadataString(`${component}.cpp`)}
 
 #include "${component}.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>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
 
 namespace ${namespace} {
 
+  using namespace facebook;
+
   extern const char ${nameVariable}[] = "${T}";
 
   ${propsClassName}::${propsClassName}(const react::PropsParserContext& context,
@@ -250,36 +200,11 @@ namespace ${namespace} {
 
   bool ${propsClassName}::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
-      ${indent(cases.join('\n'), '      ')}
+      ${indent(filterCases.join('\n'), '      ')}
       default: return false;
     }
   }
 
-  ${descriptorClassName}::${descriptorClassName}(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  std::shared_ptr<const react::Props> ${descriptorClassName}::cloneProps(const react::PropsParserContext& context,
-                                      ${descriptorIndent}             const std::shared_ptr<const react::Props>& props,
-                                      ${descriptorIndent}             react::RawProps rawProps) const {
-    // 1. Prepare raw props parser
-    rawProps.parse(rawPropsParser_);
-    // 2. Copy props with Nitro's cached copy constructor
-    return ${shadowNodeClassName}::Props(context, /* & */ rawProps, props);
-  }
-
-#ifdef ANDROID
-  void ${descriptorClassName}::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<${shadowNodeClassName}&>(shadowNode);
-    const std::shared_ptr<const ${propsClassName}>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<${propsClassName}>& props = std::const_pointer_cast<${propsClassName}>(constProps);
-    ${stateClassName} state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace ${namespace}
 `.trim()
 

package/src/views/kotlin/KotlinHybridViewManager.ts

@@ -56,6 +56,14 @@ import ${javaNamespace}.*
  * Represents the React Native \`ViewManager\` for the "${spec.name}" Nitro HybridView.
  */
 public class ${manager}: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: ${viewImplementation},
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(${viewImplementation}::class.java)) {
       // Enable view recycling
@@ -70,33 +78,41 @@ public class ${manager}: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = ${viewImplementation}(reactContext)
     val view = hybridView.view
-    view.setTag(associated_hybrid_view_tag, hybridView)
+    view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
     return view
   }
 
   override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
-    val hybridView = getHybridView(view)
+    val holder = getHybridViewHolder(view)
       ?: throw Error("Couldn't find view $view in local views table!")
+    val hybridView = holder.hybridView
+    val oldState = holder.lastState
+    val newState = stateWrapper
 
     // 1. Update each prop individually
     hybridView.beforeUpdate()
-    ${stateUpdaterName}.updateViewProps(hybridView, stateWrapper)
+    ${stateUpdaterName}.updateViewProps(hybridView, newState, oldState)
     hybridView.afterUpdate()
+    holder.lastState = newState
 
     // 2. Continue in base View props
-    return super.updateState(view, props, stateWrapper)
+    return super.updateState(view, props, newState)
   }
 
   override fun onDropViewInstance(view: View) {
-    val hybridView = getHybridView(view)
-    hybridView?.onDropView()
+    val holder = getHybridViewHolder(view)
+    holder?.lastState = null
+    holder?.hybridView?.onDropView()
     return super.onDropViewInstance(view)
   }
 
   protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
-    super.prepareToRecycleView(reactContext, view)
-    val hybridView = getHybridView(view)
+    val preparedView = super.prepareToRecycleView(reactContext, view)
       ?: return null
+    val holder = getHybridViewHolder(preparedView)
+      ?: return null
+    val hybridView = holder.hybridView
+    holder.lastState = null
 
     @Suppress("USELESS_IS_CHECK")
     if (hybridView is RecyclableView) {
@@ -110,8 +126,8 @@ public class ${manager}: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): ${viewImplementation}? {
-    return view.getTag(associated_hybrid_view_tag) as? ${viewImplementation}
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }
   `.trim()
@@ -128,11 +144,11 @@ internal class ${stateUpdaterName} {
   companion object {
     /**
      * Updates the props for [view] through C++.
-     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     * The [newState] prop is expected to contain [view]'s props as wrapped Fabric state.
      */
     @Suppress("KotlinJniMissingFunction")
     @JvmStatic
-    external fun updateViewProps(view: ${HybridTSpec}, state: StateWrapper)
+    external fun updateViewProps(view: ${HybridTSpec}, newState: StateWrapper, oldState: StateWrapper?)
   }
 }
   `.trim()
@@ -171,7 +187,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<${JHybridTSpec}::JavaPart> view,
-                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const ${propsClassName}> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {
@@ -193,9 +214,10 @@ public:
     const name = escapeCppName(p.name)
     const setter = p.getSetterName('other')
     return `
-if (props->${name}.isDirty) {
-  hybridView->${setter}(props->${name}.value);
-  props->${name}.isDirty = false;
+if (oldProps == nullptr
+      ? newProps->${name}.isProvided()
+      : !newProps->${name}.hasSameValue(oldProps->${name})) {
+  hybridView->${setter}(newProps->${name}.get());
 }
     `.trim()
   })
@@ -212,38 +234,55 @@ namespace ${cxxNamespace} {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<${stateClassName}>;
 
-void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<${JHybridTSpec}::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<${JHybridTSpec}> hybridView = javaView->get${JHybridTSpec}();
-
+std::shared_ptr<const ${propsClassName}> J${stateUpdaterName}::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
   // 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");
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
   }
-  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 ${stateClassName}& data = concreteState->getData();
-  const std::shared_ptr<${propsClassName}>& props = data.getProps();
+  const std::shared_ptr<const ${propsClassName}>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("${stateClassName}'s data doesn't contain any props!");
   }
+  return props;
+}
+
+void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<${JHybridTSpec}::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<${JHybridTSpec}> hybridView = javaView->get${JHybridTSpec}();
+  std::shared_ptr<const ${propsClassName}> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const ${propsClassName}> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
+  }
 
-  // Update all props if they are dirty
+  // Update only props that differ from the previous State snapshot.
   ${indent(propsUpdaterCalls.join('\n'), '  ')}
 
   // Update hybridRef if it changed
-  if (props->hybridRef.isDirty) {
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
     // hybridRef changed - call it with new this
-    const auto& maybeFunc = props->hybridRef.value;
+    const auto& maybeFunc = newProps->hybridRef.get();
     if (maybeFunc.has_value()) {
       maybeFunc.value()(hybridView);
     }
-    props->hybridRef.isDirty = false;
   }
 }
 

package/src/views/swift/SwiftHybridViewManager.ts

@@ -26,8 +26,12 @@ export function createSwiftHybridViewManager(
   const { HybridTSpec, HybridTSpecSwift, HybridTSpecCxx } = getHybridObjectName(
     spec.name
   )
-  const { component, descriptorClassName, propsClassName } =
-    getViewComponentNames(spec)
+  const {
+    component,
+    descriptorClassName,
+    propsClassName,
+    shadowNodeClassName,
+  } = getViewComponentNames(spec)
   const implementation = spec.config.getIosAutolinkedImplementation(spec.name)
   if (implementation?.language !== 'swift') {
     throw new Error(
@@ -40,18 +44,18 @@ export function createSwiftHybridViewManager(
     const setter = p.getSetterName('swift')
     const bridge = new SwiftCxxBridgedType(p.type, false)
     const parse = bridge.parseFromCppToSwift(
-      `newViewProps.${name}.value`,
+      `newViewProps.${name}.get()`,
       'c++'
     )
     return `
 // ${p.jsSignature}
-if (newViewProps.${name}.isDirty) {
+if (oldViewProps == nullptr
+      ? newViewProps.${name}.isProvided()
+      : !newViewProps.${name}.hasSameValue(oldViewProps->${name})) {
   swiftPart.${setter}(${indent(parse, '  ')});
-  newViewProps.${name}.isDirty = false;
 }
 `.trim()
   })
-
   const mmFile = `
 ${createFileMetadataString(`${component}.mm`)}
 
@@ -87,6 +91,7 @@ using namespace ${namespace}::views;
 
 @implementation ${component} {
   std::shared_ptr<${HybridTSpecSwift}> _hybridView;
+  BOOL _didDropView;
 }
 
 + (void) load {
@@ -100,6 +105,7 @@ using namespace ${namespace}::views;
 
 - (instancetype) init {
   if (self = [super init]) {
+    _props = ${shadowNodeClassName}::defaultSharedProps();
     std::shared_ptr<${HybridTSpec}> hybridView = ${getHybridObjectConstructorCall(spec.name)}
     _hybridView = std::dynamic_pointer_cast<${HybridTSpecSwift}>(hybridView);
     [self updateView];
@@ -119,31 +125,50 @@ using namespace ${namespace}::views;
   [self setContentView:view];
 }
 
+- (void) notifyOnDropView {
+  // A recycled component can later be invalidated. Notify only once per mount.
+  if (_didDropView) {
+    return;
+  }
+  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  _didDropView = YES;
+}
+
 - (void) updateProps:(const std::shared_ptr<const react::Props>&)props
             oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // A props update marks a newly mounted or still-active component.
+  _didDropView = NO;
+
   // 1. Downcast props
-  const auto& newViewPropsConst = *std::static_pointer_cast<${propsClassName} const>(props);
-  auto& newViewProps = const_cast<${propsClassName}&>(newViewPropsConst);
+  const auto& newViewProps = *std::static_pointer_cast<const ${propsClassName}>(props);
+  const auto* oldViewProps = static_cast<const ${propsClassName}*>(oldProps.get());
   ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
 
-  // 2. Update each prop individually
-  swiftPart.beforeUpdate();
-
-  ${indent(propAssignments.join('\n'), '  ')}
-
-  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);
+  // 2. Update only props that differ from the previous Props snapshot.
+  const bool hasTransactionPropChanges = oldViewProps == nullptr
+      ? newViewProps.hasAnyProvidedProps()
+      : !newViewProps.hasSameProps(*oldViewProps);
+  if (hasTransactionPropChanges) {
+    swiftPart.beforeUpdate();
+
+    ${indent(propAssignments.join('\n'), '    ')}
+
+    // Update hybridRef if it changed
+    if (oldViewProps == nullptr
+          ? newViewProps.hybridRef.isProvided()
+          : !newViewProps.hybridRef.hasSameValue(oldViewProps->hybridRef)) {
+      // hybridRef changed - call it with new this
+      const auto& maybeFunc = newViewProps.hybridRef.get();
+      if (maybeFunc.has_value()) {
+        maybeFunc.value()(_hybridView);
+      }
     }
-    newViewProps.hybridRef.isDirty = false;
+
+    swiftPart.afterUpdate();
   }
 
-  // 4. Continue in base class
+  // 3. Continue in base class
   [super updateProps:props oldProps:oldProps];
 }
 
@@ -152,6 +177,7 @@ using namespace ${namespace}::views;
 }
 
 - (void)prepareForRecycle {
+  [self notifyOnDropView];
   [super prepareForRecycle];
   ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
   swiftPart.maybePrepareForRecycle();
@@ -159,8 +185,7 @@ using namespace ${namespace}::views;
 
 #ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
 - (void)invalidate {
-  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
-  swiftPart.onDropView();
+  [self notifyOnDropView];
   [super invalidate];
 }
 #endif