@onekeyfe/react-native-image 3.0.156 → 3.0.157

package/android/src/main/java/com/margelo/nitro/onekeyimage/OneKeyImage.kt

@@ -180,6 +180,7 @@ internal fun oneKeyImageRequestSignature(
   height: Int,
   density: Float,
   resizeWidth: Double? = null,
+  resizeHeight: Double? = null,
 ): String = listOf(
   rawUrl,
   sourceHeadersJson.orEmpty(),
@@ -190,6 +191,7 @@ internal fun oneKeyImageRequestSignature(
   overscan.toString(),
   round.toString(),
   resizeWidth.toString(),
+  resizeHeight.toString(),
   width.toString(),
   height.toString(),
   density.toString(),
@@ -304,6 +306,14 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       field = value
       requestIdentityChanged()
     }
+  // Layout hint pair with resizeWidth; only the iOS pre-layout memory probe
+  // consumes it today, Android keys the request on the measured view size.
+  override var resizeHeight: Double? = null
+    set(value) {
+      if (field == value) return
+      field = value
+      requestIdentityChanged()
+    }
   override var loadingStrategy: OneKeyImageLoadingStrategy? = OneKeyImageLoadingStrategy.STATIC
     set(value) {
       field = value
@@ -403,6 +413,7 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
     optimizeTos = true
     round = false
     resizeWidth = null
+    resizeHeight = null
     overscan = 1.1
     loadingStrategy = OneKeyImageLoadingStrategy.STATIC
     placeholderColor = null
@@ -477,6 +488,7 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       height = hostView.height,
       density = hostView.resources.displayMetrics.density,
       resizeWidth = resizeWidth,
+      resizeHeight = resizeHeight,
     )
     if (!force && signature == lastSignature) return
     lastSignature = signature

package/ios/OneKeyImage.swift

@@ -150,6 +150,11 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       if !Self.equalOptionalDouble(resizeWidth, oldValue) { identityDidChange() }
     }
   }
+  var resizeHeight: Double? {
+    didSet {
+      if !Self.equalOptionalDouble(resizeHeight, oldValue) { identityDidChange() }
+    }
+  }
   var overscan: Double? = 1.1 {
     didSet {
       if !Self.equalOptionalDouble(overscan, oldValue) { identityDidChange() }
@@ -260,7 +265,14 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     guard !hostView.bounds.isEmpty else {
       cancelCurrentRequest(invalidateGeneration: true)
       lastRequestSignature = nil
-      showLoading(requestIsActive: false, letLibraryStartIndicator: false)
+      // A memory-cached image shown from `identityDidChange` before layout
+      // stays up; layout re-runs this load with real bounds and confirms it.
+      if !Self.shouldPreserveDisplayedImage(
+        isShowingImage: displayState == .image,
+        hasImage: hostView.image != nil
+      ) {
+        showLoading(requestIsActive: false, letLibraryStartIndicator: false)
+      }
       return
     }
     guard let rawString = sourceUri, !rawString.isEmpty else {
@@ -280,6 +292,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       contentFit?.stringValue ?? "cover",
       String(optimizeTos ?? true),
       resizeWidth.map(String.init(describing:)) ?? "",
+      resizeHeight.map(String.init(describing:)) ?? "",
       String(overscan ?? 1.1),
       String(Int(hostView.bounds.width.rounded())),
       String(Int(hostView.bounds.height.rounded())),
@@ -295,7 +308,20 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     onLoadStart?()
     guard Self.isCurrentRequestGeneration(generation, current: requestGeneration) else { return }
     if showMemoryCachedImageIfAvailable(requestIsActive: true) { return }
-    showLoading(requestIsActive: true, letLibraryStartIndicator: true)
+    // The pre-layout probe may have shown this identity from another thumbnail
+    // key (a preload's, or an earlier layout size). Keep it on screen as the
+    // placeholder while the exact rendition loads: blanking to a skeleton and
+    // redrawing is worse than the skeleton it replaced.
+    let preservedImage =
+      Self.shouldPreserveDisplayedImage(
+        isShowingImage: displayState == .image,
+        hasImage: hostView.image != nil
+      ) ? hostView.image : nil
+    showLoading(
+      requestIsActive: true,
+      letLibraryStartIndicator: true,
+      preservedImage: preservedImage
+    )
 
     if let violation = OneKeyImageSafetyPolicy.preflight(source: rawString) {
       finishWithError(violation, generation: generation)
@@ -327,7 +353,8 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       url: requestURL,
       rawURL: rawURL,
       generation: generation,
-      mayFallbackToRaw: requestURL != rawURL
+      mayFallbackToRaw: requestURL != rawURL,
+      placeholderImage: preservedImage
     )
   }
 
@@ -335,7 +362,8 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     url: URL,
     rawURL: URL,
     generation: UInt64,
-    mayFallbackToRaw: Bool
+    mayFallbackToRaw: Bool,
+    placeholderImage: UIImage? = nil
   ) {
     guard Self.isCurrentRequestGeneration(generation, current: requestGeneration) else { return }
     let rawScreenScale: CGFloat = hostView.window?.screen.scale ?? UIScreen.main.scale
@@ -363,7 +391,9 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     )
     hostView.sd_internalSetImage(
       with: url,
-      placeholderImage: nil,
+      // SDWebImage resets the image view when it starts a load; hand it the
+      // preserved image so the view keeps showing it until the load lands.
+      placeholderImage: placeholderImage,
       options: OneKeyImageRequestContext.renderOptions,
       context: context,
       setImageBlock: { [weak self] image, _, _, _ in
@@ -552,18 +582,40 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
 
   private func showLoading(
     requestIsActive: Bool,
-    letLibraryStartIndicator: Bool
+    letLibraryStartIndicator: Bool,
+    preservedImage: UIImage? = nil
   ) {
     displayState = .loading
     requestActive = requestIsActive
     resetImageTransition()
-    hostView.image = nil
     fallbackLayer.isHidden = true
+    if let preservedImage {
+      // Same identity, different thumbnail key: the image already on screen
+      // stands in for the placeholder, so no blank frame and no indicator.
+      hostView.image = preservedImage
+      skeletonIndicator.stopAnimatingIndicator()
+      hostView.backgroundColor = .clear
+      return
+    }
+    hostView.image = nil
     applyLoadingAppearance(letLibraryStartIndicator: letLibraryStartIndicator)
   }
 
+  /// Whether the image currently on screen should stay up while a load for the
+  /// SAME identity runs (bounds not laid out yet, or the laid-out request key
+  /// differs from the one the pre-layout probe hit). Pure for testability.
+  static func shouldPreserveDisplayedImage(isShowingImage: Bool, hasImage: Bool) -> Bool {
+    isShowingImage && hasImage
+  }
+
   private func showMemoryCachedImageIfAvailable(requestIsActive: Bool) -> Bool {
-    guard cachePolicy == .memory || cachePolicy == .memoryDisk,
+    // JS leaves `cachePolicy` unset for the common case and Fabric then hands
+    // Nitro a nil, which the request path already treats as memory-disk; the
+    // probe must agree, otherwise a nil policy skips the memory lookup entirely
+    // and every mount pays the async pipeline round trip (an icon skeleton
+    // frame) for an image that is already decoded in memory.
+    let effectivePolicy = cachePolicy ?? .memoryDisk
+    guard effectivePolicy == .memory || effectivePolicy == .memoryDisk,
           let sourceUri,
           let rawURL = URL(string: sourceUri) else {
       return false
@@ -583,12 +635,21 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
         hasCustomIdentity: hasCustomIdentity
       )
       : rawURL
-    let thumbnailPixelSize = OneKeyImageDecodeSizing.thumbnailPixelSize(
-      viewSize: hostView.bounds.size,
-      scale: screenScale,
-      contentFit: contentFit ?? .cover
-    )
-    func memoryCachedImage(for url: URL) -> UIImage? {
+    // The thumbnail size is part of the cache key. Laid out, it is this view's
+    // own request key; before layout it comes from the resize hints, under
+    // this view's contentFit and under `.cover` (a preload's key). With no
+    // bounds and no hint the un-thumbnailed key is the only thing to try.
+    let thumbnailCandidates: [CGSize?] = {
+      let sizes = OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: hostView.bounds.size,
+        resizeWidth: resizeWidth,
+        resizeHeight: resizeHeight,
+        scale: screenScale,
+        contentFit: contentFit ?? .cover
+      )
+      return sizes.isEmpty ? [nil] : sizes
+    }()
+    func memoryCachedImage(for url: URL, thumbnailPixelSize: CGSize?) -> UIImage? {
       let context = OneKeyImageRequestContext.make(
         headersJson: sourceHeadersJson,
         cachePolicy: cachePolicy ?? .memoryDisk,
@@ -603,6 +664,14 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       }
       return cache.imageFromMemoryCache(forKey: key)
     }
+    func memoryCachedImage(for url: URL) -> UIImage? {
+      for thumbnailPixelSize in thumbnailCandidates {
+        if let image = memoryCachedImage(for: url, thumbnailPixelSize: thumbnailPixelSize) {
+          return image
+        }
+      }
+      return nil
+    }
     guard let image = memoryCachedImage(for: requestURL)
       ?? (requestURL == rawURL ? nil : memoryCachedImage(for: rawURL)) else {
       return false

package/ios/OneKeyImageRequestContext.swift

@@ -610,6 +610,44 @@ enum OneKeyImageDecodeSizing {
     }
   }
 
+  /// Decode-thumbnail sizes worth probing the memory cache with, most specific
+  /// first. The thumbnail size is part of the SDWebImage cache key, so a probe
+  /// only hits when it reproduces the key some earlier load stored under.
+  ///
+  /// - Laid out: exactly the size this view's own request uses (`bounds` +
+  ///   `contentFit`), nothing else.
+  /// - Before layout the bounds are empty, but the JS side already knows the
+  ///   display size through the `resizeWidth` / `resizeHeight` hints (the same
+  ///   fields a preload takes). Two keys can hold the image then: the one the
+  ///   laid-out request will ask for (hint + this view's `contentFit`) and the
+  ///   one a preload stored (hint + `.cover`, see `HybridOneKeyImageCache`).
+  ///   They coincide for a square hint or `.cover`; otherwise both are probed.
+  /// - No bounds and no usable hint: nothing to probe with.
+  static func probeThumbnailPixelSizes(
+    bounds: CGSize,
+    resizeWidth: Double?,
+    resizeHeight: Double?,
+    scale: CGFloat,
+    contentFit: OneKeyImageContentFit
+  ) -> [CGSize] {
+    if bounds.width.isFinite, bounds.height.isFinite, bounds.width > 0, bounds.height > 0 {
+      return thumbnailPixelSize(viewSize: bounds, scale: scale, contentFit: contentFit)
+        .map { [$0] } ?? []
+    }
+    guard let hint = logicalViewSize(width: resizeWidth, height: resizeHeight) else {
+      return []
+    }
+    var sizes: [CGSize] = []
+    for fit in [contentFit, .cover] {
+      if let size = thumbnailPixelSize(viewSize: hint, scale: scale, contentFit: fit),
+        !sizes.contains(size)
+      {
+        sizes.append(size)
+      }
+    }
+    return sizes
+  }
+
   static func thumbnailPixelSize(
     viewSize: CGSize,
     scale: CGFloat,

package/ios/tests/OneKeyImageInfrastructureTests.swift

@@ -310,6 +310,91 @@ final class OneKeyImageInfrastructureTests: XCTestCase {
     )
   }
 
+  // The pre-layout memory probe is only useful if it reproduces a key some
+  // earlier load stored under. These pin the probe against the two real key
+  // producers: the laid-out render request (bounds + contentFit) and the
+  // preload (logicalViewSize(resizeWidth, resizeHeight) + .cover).
+  private func renderKey(bounds: CGSize, fit: OneKeyImageContentFit) throws -> CGSize {
+    try XCTUnwrap(
+      OneKeyImageDecodeSizing.thumbnailPixelSize(viewSize: bounds, scale: 3, contentFit: fit)
+    )
+  }
+
+  private func preloadKey(width: Double?, height: Double?) throws -> CGSize {
+    try renderKey(
+      bounds: try XCTUnwrap(OneKeyImageDecodeSizing.logicalViewSize(width: width, height: height)),
+      fit: .cover
+    )
+  }
+
+  func testLaidOutProbeUsesExactlyTheRenderRequestKey() throws {
+    let bounds = CGSize(width: 40, height: 64)
+    for fit in [OneKeyImageContentFit.cover, .contain, .fill, .center] {
+      XCTAssertEqual(
+        OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+          bounds: bounds, resizeWidth: 32, resizeHeight: 48, scale: 3, contentFit: fit
+        ),
+        [try renderKey(bounds: bounds, fit: fit)],
+        "\(fit)"
+      )
+    }
+  }
+
+  func testPreLayoutSquareHintMatchesPreloadAndRenderKeys() throws {
+    // A token icon: resizeWidth only, laid out square, cover. One key, shared
+    // by the preload, the laid-out request and the probe.
+    let sizes = OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+      bounds: .zero, resizeWidth: 40, resizeHeight: nil, scale: 3, contentFit: .cover
+    )
+    XCTAssertEqual(sizes, [CGSize(width: 120, height: 120)])
+    XCTAssertEqual(sizes, [try preloadKey(width: 40, height: nil)])
+    XCTAssertEqual(sizes, [try renderKey(bounds: CGSize(width: 40, height: 40), fit: .cover)])
+  }
+
+  func testPreLayoutRectangularHintProbesRenderAndPreloadKeys() throws {
+    // The README preload shape (48x64 @3) under a non-cover view: the laid-out
+    // request key comes first, the preload's cover key second, no duplicates.
+    let sizes = OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+      bounds: .zero, resizeWidth: 48, resizeHeight: 64, scale: 3, contentFit: .contain
+    )
+    XCTAssertEqual(
+      sizes,
+      [
+        try renderKey(bounds: CGSize(width: 48, height: 64), fit: .contain),
+        try preloadKey(width: 48, height: 64),
+      ]
+    )
+    XCTAssertEqual(sizes, [CGSize(width: 144, height: 192), CGSize(width: 192, height: 192)])
+    // Under cover both collapse to the preload key.
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: .zero, resizeWidth: 48, resizeHeight: 64, scale: 3, contentFit: .cover
+      ),
+      [try preloadKey(width: 48, height: 64)]
+    )
+  }
+
+  func testPreLayoutProbeWithoutHintHasNothingToTry() {
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: .zero, resizeWidth: nil, resizeHeight: nil, scale: 3, contentFit: .cover
+      ),
+      []
+    )
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: .zero, resizeWidth: 0, resizeHeight: -1, scale: 3, contentFit: .cover
+      ),
+      []
+    )
+  }
+
+  func testDisplayedImageIsPreservedOnlyWhileShowingOne() {
+    XCTAssertTrue(HybridOneKeyImage.shouldPreserveDisplayedImage(isShowingImage: true, hasImage: true))
+    XCTAssertFalse(HybridOneKeyImage.shouldPreserveDisplayedImage(isShowingImage: true, hasImage: false))
+    XCTAssertFalse(HybridOneKeyImage.shouldPreserveDisplayedImage(isShowingImage: false, hasImage: true))
+  }
+
   func testNoSizePreloadUsesCappedDecodeTarget() {
     XCTAssertEqual(HybridOneKeyImageCache.maximumConcurrentPreloads, 4)
     XCTAssertEqual(

package/lib/module/index.js

@@ -46,6 +46,7 @@ export function OneKeyImage({
   optimizeTos = true,
   round = false,
   resizeWidth,
+  resizeHeight,
   overscan = 1.1,
   loadingStrategy = OneKeyImageLoadingStrategy.STATIC,
   placeholderColor,
@@ -60,7 +61,7 @@ export function OneKeyImage({
 }) {
   const normalized = useMemo(() => normalizeSource(source), [source]);
   const resolvedCachePolicy = cachePolicy ?? normalized?.cachePolicy ?? OneKeyImageCachePolicy.MEMORY_DISK;
-  const identity = `${normalized?.uri ?? ''}|${JSON.stringify(normalized?.headers ?? {})}|${resolvedCachePolicy}|${recyclingKey ?? ''}|${contentFit}|${optimizeTos ? '1' : '0'}|${resizeWidth ?? ''}|${overscan}`;
+  const identity = `${normalized?.uri ?? ''}|${JSON.stringify(normalized?.headers ?? {})}|${resolvedCachePolicy}|${recyclingKey ?? ''}|${contentFit}|${optimizeTos ? '1' : '0'}|${resizeWidth ?? ''}|${resizeHeight ?? ''}|${overscan}`;
   const hasSource = normalized != null;
   const hasOverlay = placeholder != null || fallback != null;
   const [loadState, setLoadState] = useState({
@@ -215,6 +216,7 @@ export function OneKeyImage({
     optimizeTos,
     round,
     resizeWidth,
+    resizeHeight,
     overscan,
     loadingStrategy: placeholder == null ? loadingStrategy : OneKeyImageLoadingStrategy.NONE,
     placeholderColor

package/lib/nitrogen/generated/android/c++/JHybridOneKeyImageSpec.cpp

@@ -156,6 +156,15 @@ namespace margelo::nitro::onekeyimage {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* resizeWidth */)>("setResizeWidth");
     method(_javaPart, resizeWidth.has_value() ? jni::JDouble::valueOf(resizeWidth.value()) : nullptr);
   }
+  std::optional<double> JHybridOneKeyImageSpec::getResizeHeight() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getResizeHeight");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setResizeHeight(std::optional<double> resizeHeight) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* resizeHeight */)>("setResizeHeight");
+    method(_javaPart, resizeHeight.has_value() ? jni::JDouble::valueOf(resizeHeight.value()) : nullptr);
+  }
   std::optional<double> JHybridOneKeyImageSpec::getOverscan() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getOverscan");
     auto __result = method(_javaPart);

package/lib/nitrogen/generated/android/c++/JHybridOneKeyImageSpec.hpp

@@ -70,6 +70,8 @@ namespace margelo::nitro::onekeyimage {
     void setRound(std::optional<bool> round) override;
     std::optional<double> getResizeWidth() override;
     void setResizeWidth(std::optional<double> resizeWidth) override;
+    std::optional<double> getResizeHeight() override;
+    void setResizeHeight(std::optional<double> resizeHeight) override;
     std::optional<double> getOverscan() override;
     void setOverscan(std::optional<double> overscan) override;
     std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() override;

package/lib/nitrogen/generated/android/c++/views/JHybridOneKeyImageStateUpdater.cpp

@@ -103,6 +103,11 @@ void JHybridOneKeyImageStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
         : !newProps->resizeWidth.hasSameValue(oldProps->resizeWidth)) {
     hybridView->setResizeWidth(newProps->resizeWidth.get());
   }
+  if (oldProps == nullptr
+        ? newProps->resizeHeight.isProvided()
+        : !newProps->resizeHeight.hasSameValue(oldProps->resizeHeight)) {
+    hybridView->setResizeHeight(newProps->resizeHeight.get());
+  }
   if (oldProps == nullptr
         ? newProps->overscan.isProvided()
         : !newProps->overscan.hasSameValue(oldProps->overscan)) {

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/onekeyimage/HybridOneKeyImageSpec.kt

@@ -87,6 +87,12 @@ abstract class HybridOneKeyImageSpec: HybridView() {
   @set:Keep
   abstract var resizeWidth: Double?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var resizeHeight: Double?
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

package/lib/nitrogen/generated/ios/c++/HybridOneKeyImageSpecSwift.hpp

@@ -148,6 +148,13 @@ namespace margelo::nitro::onekeyimage {
     inline void setResizeWidth(std::optional<double> resizeWidth) noexcept override {
       _swiftPart.setResizeWidth(resizeWidth);
     }
+    inline std::optional<double> getResizeHeight() noexcept override {
+      auto __result = _swiftPart.getResizeHeight();
+      return __result;
+    }
+    inline void setResizeHeight(std::optional<double> resizeHeight) noexcept override {
+      _swiftPart.setResizeHeight(resizeHeight);
+    }
     inline std::optional<double> getOverscan() noexcept override {
       auto __result = _swiftPart.getOverscan();
       return __result;

package/lib/nitrogen/generated/ios/c++/views/HybridOneKeyImageComponent.mm

@@ -158,6 +158,12 @@ using namespace margelo::nitro::onekeyimage::views;
           : !newViewProps.resizeWidth.hasSameValue(oldViewProps->resizeWidth)) {
       swiftPart.setResizeWidth(newViewProps.resizeWidth.get());
     }
+    // resizeHeight: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.resizeHeight.isProvided()
+          : !newViewProps.resizeHeight.hasSameValue(oldViewProps->resizeHeight)) {
+      swiftPart.setResizeHeight(newViewProps.resizeHeight.get());
+    }
     // overscan: optional
     if (oldViewProps == nullptr
           ? newViewProps.overscan.isProvided()

package/lib/nitrogen/generated/ios/swift/HybridOneKeyImageSpec.swift

@@ -20,6 +20,7 @@ public protocol HybridOneKeyImageSpec_protocol: HybridObject, HybridView {
   var optimizeTos: Bool? { get set }
   var round: Bool? { get set }
   var resizeWidth: Double? { get set }
+  var resizeHeight: Double? { get set }
   var overscan: Double? { get set }
   var loadingStrategy: OneKeyImageLoadingStrategy? { get set }
   var placeholderColor: String? { get set }

package/lib/nitrogen/generated/ios/swift/HybridOneKeyImageSpec_cxx.swift

@@ -340,6 +340,30 @@ open class HybridOneKeyImageSpec_cxx {
     }
   }
   
+  public final var resizeHeight: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.resizeHeight {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.resizeHeight = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var overscan: bridge.std__optional_double_ {
     @inline(__always)
     get {

package/lib/nitrogen/generated/shared/c++/HybridOneKeyImageSpec.cpp

@@ -34,6 +34,8 @@ namespace margelo::nitro::onekeyimage {
       prototype.registerHybridSetter("round", &HybridOneKeyImageSpec::setRound);
       prototype.registerHybridGetter("resizeWidth", &HybridOneKeyImageSpec::getResizeWidth);
       prototype.registerHybridSetter("resizeWidth", &HybridOneKeyImageSpec::setResizeWidth);
+      prototype.registerHybridGetter("resizeHeight", &HybridOneKeyImageSpec::getResizeHeight);
+      prototype.registerHybridSetter("resizeHeight", &HybridOneKeyImageSpec::setResizeHeight);
       prototype.registerHybridGetter("overscan", &HybridOneKeyImageSpec::getOverscan);
       prototype.registerHybridSetter("overscan", &HybridOneKeyImageSpec::setOverscan);
       prototype.registerHybridGetter("loadingStrategy", &HybridOneKeyImageSpec::getLoadingStrategy);

package/lib/nitrogen/generated/shared/c++/HybridOneKeyImageSpec.hpp

@@ -80,6 +80,8 @@ namespace margelo::nitro::onekeyimage {
       virtual void setRound(std::optional<bool> round) = 0;
       virtual std::optional<double> getResizeWidth() = 0;
       virtual void setResizeWidth(std::optional<double> resizeWidth) = 0;
+      virtual std::optional<double> getResizeHeight() = 0;
+      virtual void setResizeHeight(std::optional<double> resizeHeight) = 0;
       virtual std::optional<double> getOverscan() = 0;
       virtual void setOverscan(std::optional<double> overscan) = 0;
       virtual std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() = 0;

package/lib/nitrogen/generated/shared/c++/views/HybridOneKeyImageComponent.cpp

@@ -30,6 +30,7 @@ namespace margelo::nitro::onekeyimage::views {
     optimizeTos(nitro::ReactProp<std::optional<bool>>::fromRawValue("OneKeyImage", "optimizeTos", rawProps, sourceProps.optimizeTos)),
     round(nitro::ReactProp<std::optional<bool>>::fromRawValue("OneKeyImage", "round", rawProps, sourceProps.round)),
     resizeWidth(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "resizeWidth", rawProps, sourceProps.resizeWidth)),
+    resizeHeight(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "resizeHeight", rawProps, sourceProps.resizeHeight)),
     overscan(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "overscan", rawProps, sourceProps.overscan)),
     loadingStrategy(nitro::ReactProp<std::optional<OneKeyImageLoadingStrategy>>::fromRawValue("OneKeyImage", "loadingStrategy", rawProps, sourceProps.loadingStrategy)),
     placeholderColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("OneKeyImage", "placeholderColor", rawProps, sourceProps.placeholderColor)),
@@ -52,6 +53,7 @@ namespace margelo::nitro::onekeyimage::views {
       case hashString("optimizeTos"): return true;
       case hashString("round"): return true;
       case hashString("resizeWidth"): return true;
+      case hashString("resizeHeight"): return true;
       case hashString("overscan"): return true;
       case hashString("loadingStrategy"): return true;
       case hashString("placeholderColor"): return true;

package/lib/nitrogen/generated/shared/c++/views/HybridOneKeyImageComponent.hpp

@@ -58,6 +58,7 @@ namespace margelo::nitro::onekeyimage::views {
     nitro::ReactProp<std::optional<bool>> optimizeTos;
     nitro::ReactProp<std::optional<bool>> round;
     nitro::ReactProp<std::optional<double>> resizeWidth;
+    nitro::ReactProp<std::optional<double>> resizeHeight;
     nitro::ReactProp<std::optional<double>> overscan;
     nitro::ReactProp<std::optional<OneKeyImageLoadingStrategy>> loadingStrategy;
     nitro::ReactProp<std::optional<std::string>> placeholderColor;
@@ -80,6 +81,7 @@ namespace margelo::nitro::onekeyimage::views {
              optimizeTos.hasSameValue(other.optimizeTos) &&
              round.hasSameValue(other.round) &&
              resizeWidth.hasSameValue(other.resizeWidth) &&
+             resizeHeight.hasSameValue(other.resizeHeight) &&
              overscan.hasSameValue(other.overscan) &&
              loadingStrategy.hasSameValue(other.loadingStrategy) &&
              placeholderColor.hasSameValue(other.placeholderColor) &&
@@ -103,6 +105,7 @@ namespace margelo::nitro::onekeyimage::views {
              optimizeTos.isProvided() ||
              round.isProvided() ||
              resizeWidth.isProvided() ||
+             resizeHeight.isProvided() ||
              overscan.isProvided() ||
              loadingStrategy.isProvided() ||
              placeholderColor.isProvided() ||

package/lib/nitrogen/generated/shared/json/OneKeyImageConfig.json

@@ -14,6 +14,7 @@
     "optimizeTos": true,
     "round": true,
     "resizeWidth": true,
+    "resizeHeight": true,
     "overscan": true,
     "loadingStrategy": true,
     "placeholderColor": true,

package/lib/typescript/src/OneKeyImage.nitro.d.ts

@@ -36,6 +36,12 @@ export interface OneKeyImageNativeProps extends HybridViewProps {
     round?: boolean;
     /** Display width hint in layout units. Native applies the screen density. */
     resizeWidth?: number;
+    /**
+     * Display height hint in layout units. With `resizeWidth` it lets the
+     * pre-layout memory-cache probe derive the same decode thumbnail a preload
+     * with the same hints stored; omitted, the hint is a square of `resizeWidth`.
+     */
+    resizeHeight?: number;
     overscan?: number;
     loadingStrategy?: OneKeyImageLoadingStrategy;
     /** Theme-aware color used by static loading, error, and fallback states. */

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

@@ -45,7 +45,7 @@ export interface OneKeyImageProps extends Omit<OneKeyImageNativeProps, 'sourceUr
     onError?: MaybeWrappedCallback<(event: OneKeyImageErrorEvent) => void>;
     onLoadEnd?: MaybeWrappedCallback<() => void>;
 }
-export declare function OneKeyImage({ source, placeholder, fallback, variant, contentFit, cachePolicy, autoplay, recyclingKey, optimizeTos, round, resizeWidth, overscan, loadingStrategy, placeholderColor, hybridRef, onLoadStart, onLoad, onDisplay, onError, onLoadEnd, style, ...viewProps }: OneKeyImageProps): import("react/jsx-runtime").JSX.Element;
+export declare function OneKeyImage({ source, placeholder, fallback, variant, contentFit, cachePolicy, autoplay, recyclingKey, optimizeTos, round, resizeWidth, resizeHeight, overscan, loadingStrategy, placeholderColor, hybridRef, onLoadStart, onLoad, onDisplay, onError, onLoadEnd, style, ...viewProps }: OneKeyImageProps): import("react/jsx-runtime").JSX.Element;
 export declare const OneKeyImageCache: {
     preload(sources: OneKeyImagePreloadInput[]): Promise<boolean>;
     clearMemory: () => Promise<void>;

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

@@ -156,6 +156,15 @@ namespace margelo::nitro::onekeyimage {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* resizeWidth */)>("setResizeWidth");
     method(_javaPart, resizeWidth.has_value() ? jni::JDouble::valueOf(resizeWidth.value()) : nullptr);
   }
+  std::optional<double> JHybridOneKeyImageSpec::getResizeHeight() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getResizeHeight");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setResizeHeight(std::optional<double> resizeHeight) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* resizeHeight */)>("setResizeHeight");
+    method(_javaPart, resizeHeight.has_value() ? jni::JDouble::valueOf(resizeHeight.value()) : nullptr);
+  }
   std::optional<double> JHybridOneKeyImageSpec::getOverscan() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getOverscan");
     auto __result = method(_javaPart);

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

@@ -70,6 +70,8 @@ namespace margelo::nitro::onekeyimage {
     void setRound(std::optional<bool> round) override;
     std::optional<double> getResizeWidth() override;
     void setResizeWidth(std::optional<double> resizeWidth) override;
+    std::optional<double> getResizeHeight() override;
+    void setResizeHeight(std::optional<double> resizeHeight) override;
     std::optional<double> getOverscan() override;
     void setOverscan(std::optional<double> overscan) override;
     std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() override;

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

@@ -103,6 +103,11 @@ void JHybridOneKeyImageStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
         : !newProps->resizeWidth.hasSameValue(oldProps->resizeWidth)) {
     hybridView->setResizeWidth(newProps->resizeWidth.get());
   }
+  if (oldProps == nullptr
+        ? newProps->resizeHeight.isProvided()
+        : !newProps->resizeHeight.hasSameValue(oldProps->resizeHeight)) {
+    hybridView->setResizeHeight(newProps->resizeHeight.get());
+  }
   if (oldProps == nullptr
         ? newProps->overscan.isProvided()
         : !newProps->overscan.hasSameValue(oldProps->overscan)) {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/onekeyimage/HybridOneKeyImageSpec.kt

@@ -87,6 +87,12 @@ abstract class HybridOneKeyImageSpec: HybridView() {
   @set:Keep
   abstract var resizeWidth: Double?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var resizeHeight: Double?
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

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

@@ -148,6 +148,13 @@ namespace margelo::nitro::onekeyimage {
     inline void setResizeWidth(std::optional<double> resizeWidth) noexcept override {
       _swiftPart.setResizeWidth(resizeWidth);
     }
+    inline std::optional<double> getResizeHeight() noexcept override {
+      auto __result = _swiftPart.getResizeHeight();
+      return __result;
+    }
+    inline void setResizeHeight(std::optional<double> resizeHeight) noexcept override {
+      _swiftPart.setResizeHeight(resizeHeight);
+    }
     inline std::optional<double> getOverscan() noexcept override {
       auto __result = _swiftPart.getOverscan();
       return __result;

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

@@ -158,6 +158,12 @@ using namespace margelo::nitro::onekeyimage::views;
           : !newViewProps.resizeWidth.hasSameValue(oldViewProps->resizeWidth)) {
       swiftPart.setResizeWidth(newViewProps.resizeWidth.get());
     }
+    // resizeHeight: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.resizeHeight.isProvided()
+          : !newViewProps.resizeHeight.hasSameValue(oldViewProps->resizeHeight)) {
+      swiftPart.setResizeHeight(newViewProps.resizeHeight.get());
+    }
     // overscan: optional
     if (oldViewProps == nullptr
           ? newViewProps.overscan.isProvided()

package/nitrogen/generated/ios/swift/HybridOneKeyImageSpec.swift

@@ -20,6 +20,7 @@ public protocol HybridOneKeyImageSpec_protocol: HybridObject, HybridView {
   var optimizeTos: Bool? { get set }
   var round: Bool? { get set }
   var resizeWidth: Double? { get set }
+  var resizeHeight: Double? { get set }
   var overscan: Double? { get set }
   var loadingStrategy: OneKeyImageLoadingStrategy? { get set }
   var placeholderColor: String? { get set }

package/nitrogen/generated/ios/swift/HybridOneKeyImageSpec_cxx.swift

@@ -340,6 +340,30 @@ open class HybridOneKeyImageSpec_cxx {
     }
   }
   
+  public final var resizeHeight: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.resizeHeight {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.resizeHeight = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var overscan: bridge.std__optional_double_ {
     @inline(__always)
     get {

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

@@ -34,6 +34,8 @@ namespace margelo::nitro::onekeyimage {
       prototype.registerHybridSetter("round", &HybridOneKeyImageSpec::setRound);
       prototype.registerHybridGetter("resizeWidth", &HybridOneKeyImageSpec::getResizeWidth);
       prototype.registerHybridSetter("resizeWidth", &HybridOneKeyImageSpec::setResizeWidth);
+      prototype.registerHybridGetter("resizeHeight", &HybridOneKeyImageSpec::getResizeHeight);
+      prototype.registerHybridSetter("resizeHeight", &HybridOneKeyImageSpec::setResizeHeight);
       prototype.registerHybridGetter("overscan", &HybridOneKeyImageSpec::getOverscan);
       prototype.registerHybridSetter("overscan", &HybridOneKeyImageSpec::setOverscan);
       prototype.registerHybridGetter("loadingStrategy", &HybridOneKeyImageSpec::getLoadingStrategy);

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

@@ -80,6 +80,8 @@ namespace margelo::nitro::onekeyimage {
       virtual void setRound(std::optional<bool> round) = 0;
       virtual std::optional<double> getResizeWidth() = 0;
       virtual void setResizeWidth(std::optional<double> resizeWidth) = 0;
+      virtual std::optional<double> getResizeHeight() = 0;
+      virtual void setResizeHeight(std::optional<double> resizeHeight) = 0;
       virtual std::optional<double> getOverscan() = 0;
       virtual void setOverscan(std::optional<double> overscan) = 0;
       virtual std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() = 0;

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

@@ -30,6 +30,7 @@ namespace margelo::nitro::onekeyimage::views {
     optimizeTos(nitro::ReactProp<std::optional<bool>>::fromRawValue("OneKeyImage", "optimizeTos", rawProps, sourceProps.optimizeTos)),
     round(nitro::ReactProp<std::optional<bool>>::fromRawValue("OneKeyImage", "round", rawProps, sourceProps.round)),
     resizeWidth(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "resizeWidth", rawProps, sourceProps.resizeWidth)),
+    resizeHeight(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "resizeHeight", rawProps, sourceProps.resizeHeight)),
     overscan(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "overscan", rawProps, sourceProps.overscan)),
     loadingStrategy(nitro::ReactProp<std::optional<OneKeyImageLoadingStrategy>>::fromRawValue("OneKeyImage", "loadingStrategy", rawProps, sourceProps.loadingStrategy)),
     placeholderColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("OneKeyImage", "placeholderColor", rawProps, sourceProps.placeholderColor)),
@@ -52,6 +53,7 @@ namespace margelo::nitro::onekeyimage::views {
       case hashString("optimizeTos"): return true;
       case hashString("round"): return true;
       case hashString("resizeWidth"): return true;
+      case hashString("resizeHeight"): return true;
       case hashString("overscan"): return true;
       case hashString("loadingStrategy"): return true;
       case hashString("placeholderColor"): return true;

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

@@ -58,6 +58,7 @@ namespace margelo::nitro::onekeyimage::views {
     nitro::ReactProp<std::optional<bool>> optimizeTos;
     nitro::ReactProp<std::optional<bool>> round;
     nitro::ReactProp<std::optional<double>> resizeWidth;
+    nitro::ReactProp<std::optional<double>> resizeHeight;
     nitro::ReactProp<std::optional<double>> overscan;
     nitro::ReactProp<std::optional<OneKeyImageLoadingStrategy>> loadingStrategy;
     nitro::ReactProp<std::optional<std::string>> placeholderColor;
@@ -80,6 +81,7 @@ namespace margelo::nitro::onekeyimage::views {
              optimizeTos.hasSameValue(other.optimizeTos) &&
              round.hasSameValue(other.round) &&
              resizeWidth.hasSameValue(other.resizeWidth) &&
+             resizeHeight.hasSameValue(other.resizeHeight) &&
              overscan.hasSameValue(other.overscan) &&
              loadingStrategy.hasSameValue(other.loadingStrategy) &&
              placeholderColor.hasSameValue(other.placeholderColor) &&
@@ -103,6 +105,7 @@ namespace margelo::nitro::onekeyimage::views {
              optimizeTos.isProvided() ||
              round.isProvided() ||
              resizeWidth.isProvided() ||
+             resizeHeight.isProvided() ||
              overscan.isProvided() ||
              loadingStrategy.isProvided() ||
              placeholderColor.isProvided() ||

package/nitrogen/generated/shared/json/OneKeyImageConfig.json

@@ -14,6 +14,7 @@
     "optimizeTos": true,
     "round": true,
     "resizeWidth": true,
+    "resizeHeight": true,
     "overscan": true,
     "loadingStrategy": true,
     "placeholderColor": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-image",
-  "version": "3.0.156",
+  "version": "3.0.157",
   "description": "High-performance native image view for OneKey",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -81,7 +81,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-skeleton": "3.0.156",
+    "@onekeyfe/react-native-skeleton": "3.0.157",
     "react": "*",
     "react-native": "*",
     "react-native-nitro-modules": "0.37.0"

package/src/OneKeyImage.nitro.ts

@@ -47,6 +47,12 @@ export interface OneKeyImageNativeProps extends HybridViewProps {
   round?: boolean;
   /** Display width hint in layout units. Native applies the screen density. */
   resizeWidth?: number;
+  /**
+   * Display height hint in layout units. With `resizeWidth` it lets the
+   * pre-layout memory-cache probe derive the same decode thumbnail a preload
+   * with the same hints stored; omitted, the hint is a square of `resizeWidth`.
+   */
+  resizeHeight?: number;
   overscan?: number;
   loadingStrategy?: OneKeyImageLoadingStrategy;
   /** Theme-aware color used by static loading, error, and fallback states. */

package/src/index.tsx

@@ -155,6 +155,7 @@ export function OneKeyImage({
   optimizeTos = true,
   round = false,
   resizeWidth,
+  resizeHeight,
   overscan = 1.1,
   loadingStrategy = OneKeyImageLoadingStrategy.STATIC,
   placeholderColor,
@@ -176,7 +177,7 @@ export function OneKeyImage({
     normalized?.headers ?? {}
   )}|${resolvedCachePolicy}|${recyclingKey ?? ''}|${contentFit}|${
     optimizeTos ? '1' : '0'
-  }|${resizeWidth ?? ''}|${overscan}`;
+  }|${resizeWidth ?? ''}|${resizeHeight ?? ''}|${overscan}`;
   const hasSource = normalized != null;
   const hasOverlay = placeholder != null || fallback != null;
   type LoadState = {
@@ -373,6 +374,7 @@ export function OneKeyImage({
     optimizeTos,
     round,
     resizeWidth,
+    resizeHeight,
     overscan,
     loadingStrategy:
       placeholder == null ? loadingStrategy : OneKeyImageLoadingStrategy.NONE,