@onekeyfe/react-native-image 3.0.156 → 3.0.157-alpha.249

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-alpha.249",
   "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-alpha.249",
     "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 = {
@@ -354,6 +355,7 @@ export function OneKeyImage({
           borderEndStartRadius: flattenedStyle.borderEndStartRadius,
           borderEndEndRadius: flattenedStyle.borderEndEndRadius,
           zIndex: 1,
+          ...(round ? ROUND_CLIP : null),
         }
       : undefined;
 
@@ -373,6 +375,7 @@ export function OneKeyImage({
     optimizeTos,
     round,
     resizeWidth,
+    resizeHeight,
     overscan,
     loadingStrategy:
       placeholder == null ? loadingStrategy : OneKeyImageLoadingStrategy.NONE,
@@ -387,6 +390,7 @@ export function OneKeyImage({
         style,
         styles.overlayContainer,
         hasRoundedCorners ? styles.borderlessContainer : undefined,
+        round ? ROUND_CLIP : undefined,
       ]}
       collapsable={false}
     >
@@ -442,6 +446,24 @@ export const OneKeyImageCache = {
   clearAll: () => nativeCache.clearAll(),
 };
 
+// `round` clips the native view to a circle: an oval path on Android
+// (`OneKeyImage.kt` `addOval`), a `min(width, height) / 2` corner radius on iOS
+// (`OneKeyImage.swift` `updateRoundMask`). The overlay container has to clip the
+// same way, or a custom placeholder or fallback is painted square over a round
+// image. A percentage radius says that without measuring the view, and covers
+// every per-corner radius the caller's own style may have set.
+const ROUND_CLIP = {
+  borderRadius: '50%',
+  borderTopLeftRadius: '50%',
+  borderTopRightRadius: '50%',
+  borderBottomLeftRadius: '50%',
+  borderBottomRightRadius: '50%',
+  borderStartStartRadius: '50%',
+  borderStartEndRadius: '50%',
+  borderEndStartRadius: '50%',
+  borderEndEndRadius: '50%',
+} as const;
+
 const styles = StyleSheet.create({
   overlayContainer: {
     overflow: 'hidden',