@onekeyfe/react-native-skeleton 3.0.95 → 3.0.98

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

@@ -37,6 +37,7 @@ using namespace margelo::nitro::skeleton::views;
 
 @implementation HybridSkeletonComponent {
   std::shared_ptr<HybridSkeletonSpecSwift> _hybridView;
+  BOOL _didDropView;
 }
 
 + (void) load {
@@ -50,6 +51,7 @@ using namespace margelo::nitro::skeleton::views;
 
 - (instancetype) init {
   if (self = [super init]) {
+    _props = HybridSkeletonShadowNode::defaultSharedProps();
     std::shared_ptr<HybridSkeletonSpec> hybridView = Skeleton::SkeletonAutolinking::createSkeleton();
     _hybridView = std::dynamic_pointer_cast<HybridSkeletonSpecSwift>(hybridView);
     [self updateView];
@@ -69,40 +71,61 @@ using namespace margelo::nitro::skeleton::views;
   [self setContentView:view];
 }
 
+- (void) notifyOnDropView {
+  // A recycled component can later be invalidated. Notify only once per mount.
+  if (_didDropView) {
+    return;
+  }
+  Skeleton::HybridSkeletonSpec_cxx& 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<HybridSkeletonProps const>(props);
-  auto& newViewProps = const_cast<HybridSkeletonProps&>(newViewPropsConst);
+  const auto& newViewProps = *std::static_pointer_cast<const HybridSkeletonProps>(props);
+  const auto* oldViewProps = static_cast<const HybridSkeletonProps*>(oldProps.get());
   Skeleton::HybridSkeletonSpec_cxx& swiftPart = _hybridView->getSwiftPart();
 
-  // 2. Update each prop individually
-  swiftPart.beforeUpdate();
-
-  // shimmerSpeed: optional
-  if (newViewProps.shimmerSpeed.isDirty) {
-    swiftPart.setShimmerSpeed(newViewProps.shimmerSpeed.value);
-    newViewProps.shimmerSpeed.isDirty = false;
-  }
-  // shimmerGradientColors: optional
-  if (newViewProps.shimmerGradientColors.isDirty) {
-    swiftPart.setShimmerGradientColors(newViewProps.shimmerGradientColors.value);
-    newViewProps.shimmerGradientColors.isDirty = false;
-  }
-
-  swiftPart.afterUpdate();
+  // 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();
+
+    // shimmerSpeed: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.shimmerSpeed.isProvided()
+          : !newViewProps.shimmerSpeed.hasSameValue(oldViewProps->shimmerSpeed)) {
+      swiftPart.setShimmerSpeed(newViewProps.shimmerSpeed.get());
+    }
+    // shimmerGradientColors: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.shimmerGradientColors.isProvided()
+          : !newViewProps.shimmerGradientColors.hasSameValue(oldViewProps->shimmerGradientColors)) {
+      swiftPart.setShimmerGradientColors(newViewProps.shimmerGradientColors.get());
+    }
 
-  // 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);
+    // 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];
 }
 
@@ -111,6 +134,7 @@ using namespace margelo::nitro::skeleton::views;
 }
 
 - (void)prepareForRecycle {
+  [self notifyOnDropView];
   [super prepareForRecycle];
   Skeleton::HybridSkeletonSpec_cxx& swiftPart = _hybridView->getSwiftPart();
   swiftPart.maybePrepareForRecycle();
@@ -118,8 +142,7 @@ using namespace margelo::nitro::skeleton::views;
 
 #ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
 - (void)invalidate {
-  Skeleton::HybridSkeletonSpec_cxx& swiftPart = _hybridView->getSwiftPart();
-  swiftPart.onDropView();
+  [self notifyOnDropView];
   [super invalidate];
 }
 #endif

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

@@ -7,55 +7,22 @@
 
 #include "HybridSkeletonComponent.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/ReactProp.hpp>
 
 namespace margelo::nitro::skeleton::views {
 
+  using namespace facebook;
+
   extern const char HybridSkeletonComponentName[] = "Skeleton";
 
   HybridSkeletonProps::HybridSkeletonProps(const react::PropsParserContext& context,
                                            const HybridSkeletonProps& sourceProps,
                                            const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    shimmerSpeed([&]() -> CachedProp<std::optional<double>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("shimmerSpeed", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.shimmerSpeed;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.shimmerSpeed);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("Skeleton.shimmerSpeed: ") + exc.what());
-      }
-    }()),
-    shimmerGradientColors([&]() -> CachedProp<std::optional<std::vector<std::string>>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("shimmerGradientColors", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.shimmerGradientColors;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<std::vector<std::string>>>::fromRawValue(*runtime, value, sourceProps.shimmerGradientColors);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("Skeleton.shimmerGradientColors: ") + exc.what());
-      }
-    }()),
-    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridSkeletonSpec>& /* 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<HybridSkeletonSpec>& /* 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("Skeleton.hybridRef: ") + exc.what());
-      }
-    }()) { }
+    shimmerSpeed(nitro::ReactProp<std::optional<double>>::fromRawValue("Skeleton", "shimmerSpeed", rawProps, sourceProps.shimmerSpeed)),
+    shimmerGradientColors(nitro::ReactProp<std::optional<std::vector<std::string>>>::fromRawValue("Skeleton", "shimmerGradientColors", rawProps, sourceProps.shimmerGradientColors)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridSkeletonSpec>& /* ref */)>>>::fromRawValue("Skeleton", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridSkeletonProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
@@ -66,29 +33,4 @@ namespace margelo::nitro::skeleton::views {
     }
   }
 
-  HybridSkeletonComponentDescriptor::HybridSkeletonComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  std::shared_ptr<const react::Props> HybridSkeletonComponentDescriptor::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 HybridSkeletonShadowNode::Props(context, /* & */ rawProps, props);
-  }
-
-#ifdef ANDROID
-  void HybridSkeletonComponentDescriptor::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<HybridSkeletonShadowNode&>(shadowNode);
-    const std::shared_ptr<const HybridSkeletonProps>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<HybridSkeletonProps>& props = std::const_pointer_cast<HybridSkeletonProps>(constProps);
-    HybridSkeletonState state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace margelo::nitro::skeleton::views

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

@@ -7,14 +7,15 @@
 
 #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/ReactProp.hpp>
+#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>
 
 #include <optional>
 #include <string>
@@ -43,9 +44,23 @@ namespace margelo::nitro::skeleton::views {
                         const react::RawProps& rawProps);
 
   public:
-    CachedProp<std::optional<double>> shimmerSpeed;
-    CachedProp<std::optional<std::vector<std::string>>> shimmerGradientColors;
-    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridSkeletonSpec>& /* ref */)>>> hybridRef;
+    nitro::ReactProp<std::optional<double>> shimmerSpeed;
+    nitro::ReactProp<std::optional<std::vector<std::string>>> shimmerGradientColors;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridSkeletonSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridSkeletonProps& other) const noexcept {
+      return shimmerSpeed.hasSameValue(other.shimmerSpeed) &&
+             shimmerGradientColors.hasSameValue(other.shimmerGradientColors) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return shimmerSpeed.isProvided() ||
+             shimmerGradientColors.isProvided() ||
+             hybridRef.isProvided();
+    }
 
   private:
     static bool filterObjectKeys(const std::string& propName);
@@ -54,32 +69,7 @@ namespace margelo::nitro::skeleton::views {
   /**
    * State for the "Skeleton" View.
    */
-  class HybridSkeletonState final {
-  public:
-    HybridSkeletonState() = default;
-    explicit HybridSkeletonState(const std::shared_ptr<HybridSkeletonProps>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<HybridSkeletonProps>& getProps() const {
-      return _props;
-    }
-
-  public:
-#ifdef ANDROID
-  HybridSkeletonState(const HybridSkeletonState& /* previousState */, folly::dynamic /* data */) {}
-  folly::dynamic getDynamic() const {
-    throw std::runtime_error("HybridSkeletonState does not support folly!");
-  }
-  react::MapBuffer getMapBuffer() const {
-    throw std::runtime_error("HybridSkeletonState does not support MapBuffer!");
-  };
-#endif
-
-  private:
-    std::shared_ptr<HybridSkeletonProps> _props;
-  };
+  using HybridSkeletonState = nitro::ViewPropsHolderState<HybridSkeletonProps>;
 
   /**
    * The Shadow Node for the "Skeleton" View.
@@ -92,21 +82,7 @@ namespace margelo::nitro::skeleton::views {
   /**
    * The Component Descriptor for the "Skeleton" View.
    */
-  class HybridSkeletonComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridSkeletonShadowNode> {
-  public:
-    explicit HybridSkeletonComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
-
-  public:
-    /**
-     * A faster path for cloning props - reuses the caching logic from `HybridSkeletonProps`.
-     */
-    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 HybridSkeletonComponentDescriptor = nitro::ViewComponentDescriptor<HybridSkeletonShadowNode>;
 
   /* The actual view for "Skeleton" needs to be implemented in platform-specific code. */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-skeleton",
-  "version": "3.0.95",
+  "version": "3.0.98",
   "description": "react-native-skeleton",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -78,12 +78,12 @@
     "eslint-plugin-prettier": "^5.5.4",
     "jest": "^29.7.0",
     "lefthook": "^2.0.3",
-    "nitrogen": "0.36.5",
+    "nitrogen": "0.37.0",
     "prettier": "^2.8.8",
     "react": "19.2.3",
     "react-native": "patch:react-native@npm%3A0.86.2#~/.yarn/patches/react-native-npm-0.86.2-c9d546616f.patch",
     "react-native-builder-bob": "^0.40.13",
-    "react-native-nitro-modules": "0.36.5",
+    "react-native-nitro-modules": "0.37.0",
     "release-it": "^19.0.4",
     "turbo": "^2.5.6",
     "typescript": "^5.9.2"
@@ -91,7 +91,7 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "0.36.5"
+    "react-native-nitro-modules": "0.37.0"
   },
   "packageManager": "yarn@4.11.0",
   "react-native-builder-bob": {