@onekeyfe/react-native-auto-size-input 3.0.131 → 3.0.133

package/android/src/main/java/com/margelo/nitro/autosizeinput/AutoSizeInput.kt

@@ -255,6 +255,8 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
       })
     }
 
+  override var keyboardAppearance: String? = null
+
   override var returnKeyType: String? = null
     get() = field
     set(value) {
@@ -337,6 +339,10 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
       if (isDisposed) return
       field = value
       view.requestLayout()
+      // requestLayout() is a no-op under React Native (the parent
+      // ReactViewGroup swallows it), so a gap change that arrives after the
+      // prefix/suffix props has to re-run the fit, which lays the row out again.
+      recalculateFontSize()
     }
 
   override var suffixMarginLeft: Double? = null
@@ -345,6 +351,10 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
       if (isDisposed) return
       field = value
       view.requestLayout()
+      // requestLayout() is a no-op under React Native (the parent
+      // ReactViewGroup swallows it), so a gap change that arrives after the
+      // prefix/suffix props has to re-run the fit, which lays the row out again.
+      recalculateFontSize()
     }
 
   override var showBorder: Boolean? = null
@@ -595,31 +605,43 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
       // In contentAutoWidth mode, prioritize width expansion instead of shrinking text.
       if (isContentAutoWidthEnabled) {
         val density = context.resources.displayMetrics.density
+        val scaledDensity = context.resources.displayMetrics.scaledDensity
         val edgeInset = (2f * density).toInt()
         val singleLineWidthPadding = contentAutoWidthPaddingPx()
-        val prefixW = if (prefixView.visibility == View.VISIBLE) measureTextViewWidthPx(prefixView) else 0
-        val suffixW = if (suffixView.visibility == View.VISIBLE) measureTextViewWidthPx(suffixView) else 0
+        val minInputWidth = (24f * density).toInt()
+        // Measure prefix/suffix at every candidate size instead of
+        // once at the current size. applyFontSize scales them together with the
+        // input, so a fit that used their old (smaller) width left performLayout
+        // with a slot narrower than the text and the EditText scrolled the
+        // leading digits out of view (send-amount fiat toggle: "$" prefix appears
+        // while the token suffix disappears and the font grows).
+        val prefixText = if (prefixView.visibility == View.VISIBLE) prefixView.text?.toString().orEmpty() else ""
+        val suffixText = if (suffixView.visibility == View.VISIBLE) suffixView.text?.toString().orEmpty() else ""
         val prefixGap = if (prefixView.visibility == View.VISIBLE) ((prefixMarginRight ?: 0.0) * density).toInt() else 0
         val suffixGap = if (suffixView.visibility == View.VISIBLE) ((suffixMarginLeft ?: 0.0) * density).toInt() else 0
-        val prefixSegment = prefixW + prefixGap
-        val suffixSegment = if (suffixView.visibility == View.VISIBLE) suffixGap + suffixW else 0
         val availableTrackWidth = maxOf(width - (edgeInset * 2), 0)
-        val maxInputWidth = maxOf(availableTrackWidth - prefixSegment - suffixSegment, 0)
-        val maxTextWidth = maxOf(maxInputWidth - singleLineWidthPadding, 0)
+        val availableGroupWidth = maxOf(availableTrackWidth - prefixGap - suffixGap, 0)
         val maxTextHeight = maxOf(height - inputView.paddingTop - inputView.paddingBottom, 0)
         val textForSizing = if (inputText.isEmpty()) (placeholder ?: "") else inputText
         val probeText = if (textForSizing.isEmpty()) "0" else textForSizing
-
-        // Keep both width and line-height within the input slot.
-        val widthFitSize = if (maxTextWidth <= 0) {
-          minSize
-        } else {
-          findOptimalFontSizeSingleLine(
-            fullText = probeText,
-            availableWidth = maxTextWidth.toFloat(),
-            minSize = minSize,
-            maxSize = maxSize
+        val typeface = makeTypeface()
+
+        // Keep both width and line-height within the input slot. The width probe
+        // mirrors performLayout: input slot (text + padding, at least the minimum
+        // width) plus both side labels, all at the candidate size.
+        val widthFitSize = AutoWidthFontFit.findLargestFittingSize(
+          minSize = minSize,
+          maxSize = maxSize,
+          availableWidth = availableGroupWidth.toFloat()
+        ) { candidateSize ->
+          val textSizePx = candidateSize * scaledDensity
+          val inputW = maxOf(
+            measureSingleLineTextWidthPx(probeText, textSizePx, typeface) + singleLineWidthPadding,
+            minInputWidth
           )
+          (inputW +
+            measureSideLabelWidthPx(prefixText, textSizePx, typeface) +
+            measureSideLabelWidthPx(suffixText, textSizePx, typeface)).toFloat()
         }
         val heightFitSize = if (maxTextHeight <= 0) {
           minSize
@@ -838,30 +860,51 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
   }
 
   private fun measureSingleLineTextWidthPx(text: String): Int {
+    return measureSingleLineTextWidthPx(
+      text,
+      currentFontSize * context.resources.displayMetrics.scaledDensity,
+      makeTypeface()
+    )
+  }
+
+  // Size-parameterized so the auto-width fit can probe candidates.
+  private fun measureSingleLineTextWidthPx(text: String, textSizePx: Float, typeface: Typeface): Int {
     if (text.isEmpty()) return 0
     val paint = TextPaint(Paint.ANTI_ALIAS_FLAG)
-    paint.textSize = currentFontSize * context.resources.displayMetrics.scaledDensity
-    paint.typeface = makeTypeface()
+    paint.textSize = textSizePx
+    paint.typeface = typeface
     return kotlin.math.ceil(paint.measureText(text).toDouble()).toInt()
   }
 
+  // Width a prefix/suffix label occupies at [textSizePx]. Shared by
+  // the auto-width fit and measureTextViewWidthPx so both agree per size.
+  private fun measureSideLabelWidthPx(text: String, textSizePx: Float, typeface: Typeface): Int {
+    if (text.isEmpty()) return 0
+    val paint = TextPaint(Paint.ANTI_ALIAS_FLAG)
+    paint.textSize = textSizePx
+    paint.typeface = typeface
+    val bounds = Rect()
+    paint.getTextBounds(text, 0, text.length, bounds)
+    val advanceWidth = kotlin.math.ceil(paint.measureText(text).toDouble()).toInt()
+    return maxOf(advanceWidth, bounds.width()) + sideLabelSafetyPaddingPx(textSizePx)
+  }
+
+  // Keep extra room for side bearings/kerning to avoid clipping on some glyphs/fonts.
+  private fun sideLabelSafetyPaddingPx(textSizePx: Float): Int {
+    val density = context.resources.displayMetrics.density
+    return maxOf((4f * density).toInt(), kotlin.math.ceil(textSizePx * 0.5f).toInt())
+  }
+
   private fun measureTextViewWidthPx(textView: TextView): Int {
     val content = textView.text?.toString().orEmpty()
     if (content.isEmpty()) return 0
-    val bounds = Rect()
-    textView.paint.getTextBounds(content, 0, content.length, bounds)
-    val advanceWidth = kotlin.math.ceil(textView.paint.measureText(content).toDouble()).toInt()
-    val glyphWidth = bounds.width()
     textView.measure(
       View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
       View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
     )
-    val desiredWidth = textView.measuredWidth
-    val density = context.resources.displayMetrics.density
-    // Keep extra room for side bearings/kerning to avoid clipping on some glyphs/fonts.
-    val safetyPadding = maxOf((4f * density).toInt(), kotlin.math.ceil(textView.textSize * 0.5f).toInt())
-    val measured = maxOf(maxOf(advanceWidth, glyphWidth), desiredWidth) + safetyPadding
-    return measured
+    val desiredWidth = textView.measuredWidth + sideLabelSafetyPaddingPx(textView.textSize)
+    val paintWidth = measureSideLabelWidthPx(content, textView.textSize, textView.typeface)
+    return maxOf(paintWidth, desiredWidth)
   }
 
   private fun requestInputFocus() {

package/android/src/main/java/com/margelo/nitro/autosizeinput/AutoWidthFontFit.kt

@@ -0,0 +1,30 @@
+package com.margelo.nitro.autosizeinput
+
+// Font fit for contentAutoWidth mode. The input text, prefix,
+// suffix and their safety padding all scale with the font, so every candidate
+// size must be measured as a whole. Measuring the side labels once at the
+// previous font size under-reports their width whenever the font grows (e.g.
+// the send-amount fiat toggle adds a "$" prefix and drops the token suffix) and
+// the layout pass then hands the input a slot narrower than its text, which
+// scrolls the leading digits out of view.
+internal object AutoWidthFontFit {
+  fun findLargestFittingSize(
+    minSize: Float,
+    maxSize: Float,
+    availableWidth: Float,
+    measureAt: (Float) -> Float
+  ): Float {
+    if (availableWidth <= 0f || maxSize <= minSize) return minSize
+    var low = minSize
+    var high = maxSize
+    while (high - low > 0.5f) {
+      val mid = (low + high) / 2f
+      if (measureAt(mid) <= availableWidth) {
+        low = mid
+      } else {
+        high = mid
+      }
+    }
+    return low
+  }
+}

package/android/src/test/java/com/margelo/nitro/autosizeinput/AutoWidthFontFitTest.kt

@@ -0,0 +1,45 @@
+package com.margelo.nitro.autosizeinput
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class AutoWidthFontFitTest {
+  // Synthetic metrics: ten digits plus a "$" prefix whose safety padding
+  // scales with the font, mirroring measureTextViewWidthPx.
+  private fun contentWidthAt(size: Float): Float {
+    val text = 10 * 0.58f * size
+    val prefix = 0.55f * size + 0.5f * size
+    return text + prefix
+  }
+
+  @Test
+  fun scalesSideLabelsWithTheCandidateSize() {
+    val available = 400f
+    val size = AutoWidthFontFit.findLargestFittingSize(16f, 67f, available, ::contentWidthAt)
+
+    assertTrue(contentWidthAt(size) <= available)
+    assertTrue(contentWidthAt(size + 0.5f) > available)
+  }
+
+  @Test
+  fun regressionPrefixMeasuredAtOldSizeOverflows() {
+    // Before the fix the prefix was measured once at the previous font size
+    // (20sp here) and only the text was fitted, so the chosen size overflowed
+    // once applyFontSize scaled the prefix up as well.
+    val available = 400f
+    val stalePrefix = 0.55f * 20f + 0.5f * 20f
+    val staleFit = AutoWidthFontFit.findLargestFittingSize(16f, 67f, available - stalePrefix) { 10 * 0.58f * it }
+    assertTrue(contentWidthAt(staleFit) > available)
+
+    val fit = AutoWidthFontFit.findLargestFittingSize(16f, 67f, available, ::contentWidthAt)
+    assertTrue(contentWidthAt(fit) <= available)
+    assertTrue(fit < staleFit)
+  }
+
+  @Test
+  fun returnsMinSizeWhenNothingFits() {
+    assertEquals(16f, AutoWidthFontFit.findLargestFittingSize(16f, 67f, 0f, ::contentWidthAt), 0f)
+    assertEquals(16f, AutoWidthFontFit.findLargestFittingSize(16f, 67f, 10f, ::contentWidthAt), 0f)
+  }
+}

package/ios/AutoSizeInput.swift

@@ -203,6 +203,14 @@ class HybridAutoSizeInput: HybridAutoSizeInputSpec {
     }
   }
 
+  var keyboardAppearance: String? {
+    didSet {
+      let appearance = keyboardAppearanceFrom(keyboardAppearance)
+      singleLineInput.keyboardAppearance = appearance
+      multiLineInput.keyboardAppearance = appearance
+    }
+  }
+
   var returnKeyType: String? {
     didSet {
       let rkt = returnKeyTypeFrom(returnKeyType)
@@ -703,6 +711,14 @@ class HybridAutoSizeInput: HybridAutoSizeInputSpec {
     }
   }
 
+  private func keyboardAppearanceFrom(_ appearance: String?) -> UIKeyboardAppearance {
+    switch appearance {
+    case "light": return .light
+    case "dark": return .dark
+    default: return .default
+    }
+  }
+
   private func autoCapitalizeTypeFrom(_ type: String?) -> UITextAutocapitalizationType {
     switch type {
     case "characters": return .allCharacters

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

@@ -208,6 +208,15 @@ namespace margelo::nitro::autosizeinput {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* keyboardType */)>("setKeyboardType");
     method(_javaPart, keyboardType.has_value() ? jni::make_jstring(keyboardType.value()) : nullptr);
   }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getKeyboardAppearance() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getKeyboardAppearance");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* keyboardAppearance */)>("setKeyboardAppearance");
+    method(_javaPart, keyboardAppearance.has_value() ? jni::make_jstring(keyboardAppearance.value()) : nullptr);
+  }
   std::optional<std::string> JHybridAutoSizeInputSpec::getReturnKeyType() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getReturnKeyType");
     auto __result = method(_javaPart);

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

@@ -86,6 +86,8 @@ namespace margelo::nitro::autosizeinput {
     void setEditable(std::optional<bool> editable) override;
     std::optional<std::string> getKeyboardType() override;
     void setKeyboardType(const std::optional<std::string>& keyboardType) override;
+    std::optional<std::string> getKeyboardAppearance() override;
+    void setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) override;
     std::optional<std::string> getReturnKeyType() override;
     void setReturnKeyType(const std::optional<std::string>& returnKeyType) override;
     std::optional<bool> getAutoCorrect() override;

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

@@ -143,6 +143,11 @@ void JHybridAutoSizeInputStateUpdater::updateViewProps(jni::alias_ref<jni::JClas
         : !newProps->keyboardType.hasSameValue(oldProps->keyboardType)) {
     hybridView->setKeyboardType(newProps->keyboardType.get());
   }
+  if (oldProps == nullptr
+        ? newProps->keyboardAppearance.isProvided()
+        : !newProps->keyboardAppearance.hasSameValue(oldProps->keyboardAppearance)) {
+    hybridView->setKeyboardAppearance(newProps->keyboardAppearance.get());
+  }
   if (oldProps == nullptr
         ? newProps->returnKeyType.isProvided()
         : !newProps->returnKeyType.hasSameValue(oldProps->returnKeyType)) {

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/autosizeinput/HybridAutoSizeInputSpec.kt

@@ -135,6 +135,12 @@ abstract class HybridAutoSizeInputSpec: HybridView() {
   @set:Keep
   abstract var keyboardType: String?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var keyboardAppearance: String?
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

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

@@ -190,6 +190,13 @@ namespace margelo::nitro::autosizeinput {
     inline void setKeyboardType(const std::optional<std::string>& keyboardType) noexcept override {
       _swiftPart.setKeyboardType(keyboardType);
     }
+    inline std::optional<std::string> getKeyboardAppearance() noexcept override {
+      auto __result = _swiftPart.getKeyboardAppearance();
+      return __result;
+    }
+    inline void setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) noexcept override {
+      _swiftPart.setKeyboardAppearance(keyboardAppearance);
+    }
     inline std::optional<std::string> getReturnKeyType() noexcept override {
       auto __result = _swiftPart.getReturnKeyType();
       return __result;

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

@@ -206,6 +206,12 @@ using namespace margelo::nitro::autosizeinput::views;
           : !newViewProps.keyboardType.hasSameValue(oldViewProps->keyboardType)) {
       swiftPart.setKeyboardType(newViewProps.keyboardType.get());
     }
+    // keyboardAppearance: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.keyboardAppearance.isProvided()
+          : !newViewProps.keyboardAppearance.hasSameValue(oldViewProps->keyboardAppearance)) {
+      swiftPart.setKeyboardAppearance(newViewProps.keyboardAppearance.get());
+    }
     // returnKeyType: optional
     if (oldViewProps == nullptr
           ? newViewProps.returnKeyType.isProvided()

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

@@ -28,6 +28,7 @@ public protocol HybridAutoSizeInputSpec_protocol: HybridObject, HybridView {
   var fontWeight: String? { get set }
   var editable: Bool? { get set }
   var keyboardType: String? { get set }
+  var keyboardAppearance: String? { get set }
   var returnKeyType: String? { get set }
   var autoCorrect: Bool? { get set }
   var autoCapitalize: String? { get set }

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

@@ -553,6 +553,30 @@ open class HybridAutoSizeInputSpec_cxx {
     }
   }
   
+  public final var keyboardAppearance: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.keyboardAppearance {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.keyboardAppearance = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var returnKeyType: bridge.std__optional_std__string_ {
     @inline(__always)
     get {

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

@@ -50,6 +50,8 @@ namespace margelo::nitro::autosizeinput {
       prototype.registerHybridSetter("editable", &HybridAutoSizeInputSpec::setEditable);
       prototype.registerHybridGetter("keyboardType", &HybridAutoSizeInputSpec::getKeyboardType);
       prototype.registerHybridSetter("keyboardType", &HybridAutoSizeInputSpec::setKeyboardType);
+      prototype.registerHybridGetter("keyboardAppearance", &HybridAutoSizeInputSpec::getKeyboardAppearance);
+      prototype.registerHybridSetter("keyboardAppearance", &HybridAutoSizeInputSpec::setKeyboardAppearance);
       prototype.registerHybridGetter("returnKeyType", &HybridAutoSizeInputSpec::getReturnKeyType);
       prototype.registerHybridSetter("returnKeyType", &HybridAutoSizeInputSpec::setReturnKeyType);
       prototype.registerHybridGetter("autoCorrect", &HybridAutoSizeInputSpec::getAutoCorrect);

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

@@ -82,6 +82,8 @@ namespace margelo::nitro::autosizeinput {
       virtual void setEditable(std::optional<bool> editable) = 0;
       virtual std::optional<std::string> getKeyboardType() = 0;
       virtual void setKeyboardType(const std::optional<std::string>& keyboardType) = 0;
+      virtual std::optional<std::string> getKeyboardAppearance() = 0;
+      virtual void setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) = 0;
       virtual std::optional<std::string> getReturnKeyType() = 0;
       virtual void setReturnKeyType(const std::optional<std::string>& returnKeyType) = 0;
       virtual std::optional<bool> getAutoCorrect() = 0;

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

@@ -38,6 +38,7 @@ namespace margelo::nitro::autosizeinput::views {
     fontWeight(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "fontWeight", rawProps, sourceProps.fontWeight)),
     editable(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "editable", rawProps, sourceProps.editable)),
     keyboardType(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "keyboardType", rawProps, sourceProps.keyboardType)),
+    keyboardAppearance(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "keyboardAppearance", rawProps, sourceProps.keyboardAppearance)),
     returnKeyType(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "returnKeyType", rawProps, sourceProps.returnKeyType)),
     autoCorrect(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "autoCorrect", rawProps, sourceProps.autoCorrect)),
     autoCapitalize(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "autoCapitalize", rawProps, sourceProps.autoCapitalize)),
@@ -73,6 +74,7 @@ namespace margelo::nitro::autosizeinput::views {
       case hashString("fontWeight"): return true;
       case hashString("editable"): return true;
       case hashString("keyboardType"): return true;
+      case hashString("keyboardAppearance"): return true;
       case hashString("returnKeyType"): return true;
       case hashString("autoCorrect"): return true;
       case hashString("autoCapitalize"): return true;

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

@@ -61,6 +61,7 @@ namespace margelo::nitro::autosizeinput::views {
     nitro::ReactProp<std::optional<std::string>> fontWeight;
     nitro::ReactProp<std::optional<bool>> editable;
     nitro::ReactProp<std::optional<std::string>> keyboardType;
+    nitro::ReactProp<std::optional<std::string>> keyboardAppearance;
     nitro::ReactProp<std::optional<std::string>> returnKeyType;
     nitro::ReactProp<std::optional<bool>> autoCorrect;
     nitro::ReactProp<std::optional<std::string>> autoCapitalize;
@@ -96,6 +97,7 @@ namespace margelo::nitro::autosizeinput::views {
              fontWeight.hasSameValue(other.fontWeight) &&
              editable.hasSameValue(other.editable) &&
              keyboardType.hasSameValue(other.keyboardType) &&
+             keyboardAppearance.hasSameValue(other.keyboardAppearance) &&
              returnKeyType.hasSameValue(other.returnKeyType) &&
              autoCorrect.hasSameValue(other.autoCorrect) &&
              autoCapitalize.hasSameValue(other.autoCapitalize) &&
@@ -132,6 +134,7 @@ namespace margelo::nitro::autosizeinput::views {
              fontWeight.isProvided() ||
              editable.isProvided() ||
              keyboardType.isProvided() ||
+             keyboardAppearance.isProvided() ||
              returnKeyType.isProvided() ||
              autoCorrect.isProvided() ||
              autoCapitalize.isProvided() ||

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

@@ -22,6 +22,7 @@
     "fontWeight": true,
     "editable": true,
     "keyboardType": true,
+    "keyboardAppearance": true,
     "returnKeyType": true,
     "autoCorrect": true,
     "autoCapitalize": true,

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

@@ -18,6 +18,7 @@ export interface AutoSizeInputProps extends HybridViewProps {
     fontWeight?: string;
     editable?: boolean;
     keyboardType?: string;
+    keyboardAppearance?: string;
     returnKeyType?: string;
     autoCorrect?: boolean;
     autoCapitalize?: string;

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

@@ -208,6 +208,15 @@ namespace margelo::nitro::autosizeinput {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* keyboardType */)>("setKeyboardType");
     method(_javaPart, keyboardType.has_value() ? jni::make_jstring(keyboardType.value()) : nullptr);
   }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getKeyboardAppearance() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getKeyboardAppearance");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* keyboardAppearance */)>("setKeyboardAppearance");
+    method(_javaPart, keyboardAppearance.has_value() ? jni::make_jstring(keyboardAppearance.value()) : nullptr);
+  }
   std::optional<std::string> JHybridAutoSizeInputSpec::getReturnKeyType() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getReturnKeyType");
     auto __result = method(_javaPart);

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

@@ -86,6 +86,8 @@ namespace margelo::nitro::autosizeinput {
     void setEditable(std::optional<bool> editable) override;
     std::optional<std::string> getKeyboardType() override;
     void setKeyboardType(const std::optional<std::string>& keyboardType) override;
+    std::optional<std::string> getKeyboardAppearance() override;
+    void setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) override;
     std::optional<std::string> getReturnKeyType() override;
     void setReturnKeyType(const std::optional<std::string>& returnKeyType) override;
     std::optional<bool> getAutoCorrect() override;

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

@@ -143,6 +143,11 @@ void JHybridAutoSizeInputStateUpdater::updateViewProps(jni::alias_ref<jni::JClas
         : !newProps->keyboardType.hasSameValue(oldProps->keyboardType)) {
     hybridView->setKeyboardType(newProps->keyboardType.get());
   }
+  if (oldProps == nullptr
+        ? newProps->keyboardAppearance.isProvided()
+        : !newProps->keyboardAppearance.hasSameValue(oldProps->keyboardAppearance)) {
+    hybridView->setKeyboardAppearance(newProps->keyboardAppearance.get());
+  }
   if (oldProps == nullptr
         ? newProps->returnKeyType.isProvided()
         : !newProps->returnKeyType.hasSameValue(oldProps->returnKeyType)) {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/autosizeinput/HybridAutoSizeInputSpec.kt

@@ -135,6 +135,12 @@ abstract class HybridAutoSizeInputSpec: HybridView() {
   @set:Keep
   abstract var keyboardType: String?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var keyboardAppearance: String?
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

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

@@ -190,6 +190,13 @@ namespace margelo::nitro::autosizeinput {
     inline void setKeyboardType(const std::optional<std::string>& keyboardType) noexcept override {
       _swiftPart.setKeyboardType(keyboardType);
     }
+    inline std::optional<std::string> getKeyboardAppearance() noexcept override {
+      auto __result = _swiftPart.getKeyboardAppearance();
+      return __result;
+    }
+    inline void setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) noexcept override {
+      _swiftPart.setKeyboardAppearance(keyboardAppearance);
+    }
     inline std::optional<std::string> getReturnKeyType() noexcept override {
       auto __result = _swiftPart.getReturnKeyType();
       return __result;

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

@@ -206,6 +206,12 @@ using namespace margelo::nitro::autosizeinput::views;
           : !newViewProps.keyboardType.hasSameValue(oldViewProps->keyboardType)) {
       swiftPart.setKeyboardType(newViewProps.keyboardType.get());
     }
+    // keyboardAppearance: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.keyboardAppearance.isProvided()
+          : !newViewProps.keyboardAppearance.hasSameValue(oldViewProps->keyboardAppearance)) {
+      swiftPart.setKeyboardAppearance(newViewProps.keyboardAppearance.get());
+    }
     // returnKeyType: optional
     if (oldViewProps == nullptr
           ? newViewProps.returnKeyType.isProvided()

package/nitrogen/generated/ios/swift/HybridAutoSizeInputSpec.swift

@@ -28,6 +28,7 @@ public protocol HybridAutoSizeInputSpec_protocol: HybridObject, HybridView {
   var fontWeight: String? { get set }
   var editable: Bool? { get set }
   var keyboardType: String? { get set }
+  var keyboardAppearance: String? { get set }
   var returnKeyType: String? { get set }
   var autoCorrect: Bool? { get set }
   var autoCapitalize: String? { get set }

package/nitrogen/generated/ios/swift/HybridAutoSizeInputSpec_cxx.swift

@@ -553,6 +553,30 @@ open class HybridAutoSizeInputSpec_cxx {
     }
   }
   
+  public final var keyboardAppearance: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.keyboardAppearance {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.keyboardAppearance = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var returnKeyType: bridge.std__optional_std__string_ {
     @inline(__always)
     get {

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

@@ -50,6 +50,8 @@ namespace margelo::nitro::autosizeinput {
       prototype.registerHybridSetter("editable", &HybridAutoSizeInputSpec::setEditable);
       prototype.registerHybridGetter("keyboardType", &HybridAutoSizeInputSpec::getKeyboardType);
       prototype.registerHybridSetter("keyboardType", &HybridAutoSizeInputSpec::setKeyboardType);
+      prototype.registerHybridGetter("keyboardAppearance", &HybridAutoSizeInputSpec::getKeyboardAppearance);
+      prototype.registerHybridSetter("keyboardAppearance", &HybridAutoSizeInputSpec::setKeyboardAppearance);
       prototype.registerHybridGetter("returnKeyType", &HybridAutoSizeInputSpec::getReturnKeyType);
       prototype.registerHybridSetter("returnKeyType", &HybridAutoSizeInputSpec::setReturnKeyType);
       prototype.registerHybridGetter("autoCorrect", &HybridAutoSizeInputSpec::getAutoCorrect);

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

@@ -82,6 +82,8 @@ namespace margelo::nitro::autosizeinput {
       virtual void setEditable(std::optional<bool> editable) = 0;
       virtual std::optional<std::string> getKeyboardType() = 0;
       virtual void setKeyboardType(const std::optional<std::string>& keyboardType) = 0;
+      virtual std::optional<std::string> getKeyboardAppearance() = 0;
+      virtual void setKeyboardAppearance(const std::optional<std::string>& keyboardAppearance) = 0;
       virtual std::optional<std::string> getReturnKeyType() = 0;
       virtual void setReturnKeyType(const std::optional<std::string>& returnKeyType) = 0;
       virtual std::optional<bool> getAutoCorrect() = 0;

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

@@ -38,6 +38,7 @@ namespace margelo::nitro::autosizeinput::views {
     fontWeight(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "fontWeight", rawProps, sourceProps.fontWeight)),
     editable(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "editable", rawProps, sourceProps.editable)),
     keyboardType(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "keyboardType", rawProps, sourceProps.keyboardType)),
+    keyboardAppearance(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "keyboardAppearance", rawProps, sourceProps.keyboardAppearance)),
     returnKeyType(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "returnKeyType", rawProps, sourceProps.returnKeyType)),
     autoCorrect(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "autoCorrect", rawProps, sourceProps.autoCorrect)),
     autoCapitalize(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "autoCapitalize", rawProps, sourceProps.autoCapitalize)),
@@ -73,6 +74,7 @@ namespace margelo::nitro::autosizeinput::views {
       case hashString("fontWeight"): return true;
       case hashString("editable"): return true;
       case hashString("keyboardType"): return true;
+      case hashString("keyboardAppearance"): return true;
       case hashString("returnKeyType"): return true;
       case hashString("autoCorrect"): return true;
       case hashString("autoCapitalize"): return true;

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

@@ -61,6 +61,7 @@ namespace margelo::nitro::autosizeinput::views {
     nitro::ReactProp<std::optional<std::string>> fontWeight;
     nitro::ReactProp<std::optional<bool>> editable;
     nitro::ReactProp<std::optional<std::string>> keyboardType;
+    nitro::ReactProp<std::optional<std::string>> keyboardAppearance;
     nitro::ReactProp<std::optional<std::string>> returnKeyType;
     nitro::ReactProp<std::optional<bool>> autoCorrect;
     nitro::ReactProp<std::optional<std::string>> autoCapitalize;
@@ -96,6 +97,7 @@ namespace margelo::nitro::autosizeinput::views {
              fontWeight.hasSameValue(other.fontWeight) &&
              editable.hasSameValue(other.editable) &&
              keyboardType.hasSameValue(other.keyboardType) &&
+             keyboardAppearance.hasSameValue(other.keyboardAppearance) &&
              returnKeyType.hasSameValue(other.returnKeyType) &&
              autoCorrect.hasSameValue(other.autoCorrect) &&
              autoCapitalize.hasSameValue(other.autoCapitalize) &&
@@ -132,6 +134,7 @@ namespace margelo::nitro::autosizeinput::views {
              fontWeight.isProvided() ||
              editable.isProvided() ||
              keyboardType.isProvided() ||
+             keyboardAppearance.isProvided() ||
              returnKeyType.isProvided() ||
              autoCorrect.isProvided() ||
              autoCapitalize.isProvided() ||

package/nitrogen/generated/shared/json/AutoSizeInputConfig.json

@@ -22,6 +22,7 @@
     "fontWeight": true,
     "editable": true,
     "keyboardType": true,
+    "keyboardAppearance": true,
     "returnKeyType": true,
     "autoCorrect": true,
     "autoCapitalize": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-auto-size-input",
-  "version": "3.0.131",
+  "version": "3.0.133",
   "description": "Auto-sizing text input with font scaling, prefix and suffix support",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/AutoSizeInput.nitro.ts

@@ -34,6 +34,7 @@ export interface AutoSizeInputProps extends HybridViewProps {
 
   // Keyboard & input behavior
   keyboardType?: string;
+  keyboardAppearance?: string;
   returnKeyType?: string;
   autoCorrect?: boolean;
   autoCapitalize?: string;