@onekeyfe/react-native-auto-size-input 3.0.81-alpha.8 → 3.0.82

package/android/build.gradle

@@ -125,4 +125,5 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation project(":react-native-nitro-modules")
+  testImplementation "junit:junit:4.13.2"
 }

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

@@ -8,7 +8,6 @@ import android.graphics.drawable.GradientDrawable
 import android.os.Looper
 import android.text.Editable
 import android.text.InputType
-import android.view.inputmethod.EditorInfo
 import android.text.StaticLayout
 import android.text.TextPaint
 import android.text.TextWatcher
@@ -16,6 +15,7 @@ import android.util.TypedValue
 import android.view.Gravity
 import android.view.View
 import android.view.ViewGroup
+import android.view.inputmethod.EditorInfo
 import android.widget.EditText
 import android.widget.TextView
 import com.facebook.proguard.annotations.DoNotStrip
@@ -36,6 +36,7 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
   private var isDisposed = false
   private var maxFontSizeProp: Double? = null
   private var minFontSizeProp: Double? = null
+  private val textUpdateEventCounter = TextUpdateEventCounter()
 
   // Container view
   override val view: View = object : ViewGroup(context) {
@@ -57,25 +58,52 @@ class HybridAutoSizeInput(val context: ThemedReactContext) : HybridAutoSizeInput
     override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
     override fun afterTextChanged(s: Editable?) {
       if (isUpdatingFromJS || isDisposed) return
+      textUpdateEventCounter.recordNativeChange()
       recalculateFontSize()
       onChangeText?.invoke(s?.toString() ?: "")
     }
   }
 
+  // Last text JS requested (cached even when the update is rejected as
+  // stale): a sanitize-to-same-string edit is acknowledged with a count-only
+  // prop update, and the reapply below is what rolls the view back.
+  private var lastJsText: String? = null
+
   // Props
+  override var mostRecentEventCount: Double?
+    get() = textUpdateEventCounter.mostRecentEventCount?.toDouble()
+    set(value) {
+      // null keeps the caller out of stale-update filtering (legacy callers
+      // that never send the count must not have their text updates dropped).
+      // Sanitization (finite, integral, non-negative, Int-range — identical
+      // to iOS) also degrades malformed values to uncounted.
+      val count = TextUpdateEventCounter.sanitizeAcknowledgement(value)
+      if (textUpdateEventCounter.acknowledge(count)) {
+        lastJsText?.let { applyJsText(it) }
+      }
+    }
+
   override var text: String?
     get() = inputView.text?.toString()
     set(value) {
       if (isDisposed) return
-      isUpdatingFromJS = true
-      inputView.removeTextChangedListener(textWatcher)
-      inputView.setText(value ?: "")
-      inputView.setSelection(inputView.text?.length ?: 0)
-      inputView.addTextChangedListener(textWatcher)
-      isUpdatingFromJS = false
-      recalculateFontSize()
+      lastJsText = value ?: ""
+      if (!textUpdateEventCounter.canApplyJsUpdate()) return
+      applyJsText(value ?: "")
     }
 
+  private fun applyJsText(nextText: String) {
+    if (isDisposed) return
+    if (inputView.text?.toString() == nextText) return
+    isUpdatingFromJS = true
+    inputView.removeTextChangedListener(textWatcher)
+    inputView.setText(nextText)
+    inputView.setSelection(inputView.text?.length ?: 0)
+    inputView.addTextChangedListener(textWatcher)
+    isUpdatingFromJS = false
+    recalculateFontSize()
+  }
+
   override var prefix: String?
     get() = prefixView.text?.toString()
     set(value) {

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

@@ -0,0 +1,46 @@
+package com.margelo.nitro.autosizeinput
+
+import kotlin.math.floor
+
+internal class TextUpdateEventCounter {
+  companion object {
+    // Valid acknowledgements are exact, non-negative Int values; anything
+    // else from the JS Double prop (NaN, infinities, fractional, negative,
+    // beyond Int.MAX_VALUE) degrades to null = uncounted. Must stay in
+    // lockstep with the iOS validation so the same prop value can never be
+    // stale on one platform and current on the other.
+    fun sanitizeAcknowledgement(value: Double?): Int? {
+      if (value == null || !value.isFinite()) return null
+      if (value < 0 || value > Int.MAX_VALUE.toDouble()) return null
+      if (value != floor(value)) return null
+      return value.toInt()
+    }
+  }
+  var nativeEventCount: Int = 0
+    private set
+
+  // null = the caller never supplied mostRecentEventCount. Such callers do not
+  // participate in stale-update filtering and their JS text updates always
+  // apply (programmatic clears, sanitization, form restores). Only callers
+  // that echo the event count back opt into the comparison.
+  var mostRecentEventCount: Int? = null
+
+  fun recordNativeChange() {
+    nativeEventCount += 1
+  }
+
+  fun canApplyJsUpdate(): Boolean {
+    val acknowledged = mostRecentEventCount ?: return true
+    return acknowledged >= nativeEventCount
+  }
+
+  // Records the JS acknowledgement and reports whether the cached controlled
+  // text must be reapplied now: when JS sanitizes an edit back to the SAME
+  // string, React re-sends only the count (unchanged props are not re-sent),
+  // so catching up on a count-only update is the signal to roll the view back
+  // to the last requested JS text.
+  fun acknowledge(count: Int?): Boolean {
+    mostRecentEventCount = count
+    return count != null && canApplyJsUpdate()
+  }
+}

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

@@ -0,0 +1,147 @@
+package com.margelo.nitro.autosizeinput
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class TextUpdateEventCounterTest {
+  @Test
+  fun allowsJsUpdatesBeforeNativeInput() {
+    val counter = TextUpdateEventCounter()
+
+    assertTrue(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun allowsUncountedProgrammaticResetAfterNativeEdits() {
+    // Regression: callers that never supply mostRecentEventCount must keep
+    // full control — a native edit followed by an uncounted reset (clear,
+    // sanitization, form restore) has to apply.
+    val counter = TextUpdateEventCounter()
+    repeat(3) {
+      counter.recordNativeChange()
+    }
+
+    assertTrue(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun sanitizesAcknowledgementsToExactNonNegativeInts() {
+    // Valid: exact non-negative integral doubles in the Int range.
+    assertEquals(0, TextUpdateEventCounter.sanitizeAcknowledgement(0.0))
+    assertEquals(3, TextUpdateEventCounter.sanitizeAcknowledgement(3.0))
+    assertEquals(
+      Int.MAX_VALUE,
+      TextUpdateEventCounter.sanitizeAcknowledgement(Int.MAX_VALUE.toDouble()),
+    )
+    // Everything else degrades to uncounted — fractional values must NOT be
+    // truncated or rounded (1.6 with a native count of 2 would otherwise be
+    // stale on Android yet current on iOS).
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(null))
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(1.6))
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(-1.0))
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(Double.NaN))
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(Double.POSITIVE_INFINITY))
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(Double.NEGATIVE_INFINITY))
+    assertEquals(null, TextUpdateEventCounter.sanitizeAcknowledgement(Int.MAX_VALUE.toDouble() + 1.0))
+  }
+
+  @Test
+  fun countOnlyAcknowledgementRequestsReapplyOnceCaughtUp() {
+    // Sanitize-to-same-string edit: the user's rejected character bumped the
+    // native count, JS keeps its (unchanged) text and acknowledges via the
+    // count prop only — catching up must request a reapply of the cached
+    // JS text, a stale acknowledgement must not.
+    val counter = TextUpdateEventCounter()
+    counter.recordNativeChange()
+    counter.recordNativeChange()
+
+    assertFalse(counter.acknowledge(1))
+    assertTrue(counter.acknowledge(2))
+  }
+
+  @Test
+  fun nullAcknowledgementNeverRequestsReapply() {
+    val counter = TextUpdateEventCounter()
+    counter.recordNativeChange()
+
+    assertFalse(counter.acknowledge(null))
+    assertTrue(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun optsIntoStaleFilteringOnlyOnceACountIsSupplied() {
+    val counter = TextUpdateEventCounter()
+    counter.recordNativeChange()
+
+    assertTrue(counter.canApplyJsUpdate())
+
+    counter.mostRecentEventCount = 0
+    assertFalse(counter.canApplyJsUpdate())
+
+    counter.mostRecentEventCount = 1
+    assertTrue(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun rejectsJsUpdatesThatAreOlderThanNativeInput() {
+    val counter = TextUpdateEventCounter()
+    counter.recordNativeChange()
+    counter.recordNativeChange()
+    counter.mostRecentEventCount = 1
+
+    assertFalse(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun allowsTheLatestAcknowledgedJsUpdate() {
+    val counter = TextUpdateEventCounter()
+    counter.recordNativeChange()
+    counter.recordNativeChange()
+    counter.mostRecentEventCount = 2
+
+    assertTrue(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun tracksEveryNativeTextChange() {
+    val counter = TextUpdateEventCounter()
+
+    repeat(10) {
+      counter.recordNativeChange()
+    }
+
+    assertEquals(10, counter.nativeEventCount)
+  }
+
+  @Test
+  fun allowsAnAcknowledgedDeletionWithoutNewerInput() {
+    val counter = TextUpdateEventCounter()
+    repeat(4) {
+      counter.recordNativeChange()
+    }
+    counter.mostRecentEventCount = 4
+    counter.recordNativeChange()
+    counter.mostRecentEventCount = 5
+
+    assertTrue(counter.canApplyJsUpdate())
+  }
+
+  @Test
+  fun rejectsAStaleDeletionUpdateAfterTheNextDigit() {
+    val counter = TextUpdateEventCounter()
+    repeat(4) {
+      counter.recordNativeChange()
+    }
+    counter.mostRecentEventCount = 4
+    counter.recordNativeChange()
+    counter.recordNativeChange()
+    counter.mostRecentEventCount = 5
+
+    assertFalse(counter.canApplyJsUpdate())
+
+    counter.mostRecentEventCount = 6
+    assertTrue(counter.canApplyJsUpdate())
+  }
+}

package/ios/AutoSizeInput.swift

@@ -20,9 +20,64 @@ class HybridAutoSizeInput: HybridAutoSizeInputSpec {
   var view: UIView = UIView()
 
   // MARK: - Props
+  // Mirrors Android's TextUpdateEventCounter: every user edit bumps
+  // nativeEventCount, and a controlled `text` update only applies once the
+  // caller's acknowledged count has caught up — otherwise a delayed JS value
+  // would overwrite newer typed input. Callers that never supply
+  // mostRecentEventCount do not participate and their updates always apply.
+  private var nativeEventCount = 0
+
+  // Last text JS requested (cached even when the update is rejected as
+  // stale): a sanitize-to-same-string edit is acknowledged with a count-only
+  // prop update, and the reapply in mostRecentEventCount.didSet is what rolls
+  // the view back.
+  private var lastJsText: String?
+
+  var mostRecentEventCount: Double? {
+    didSet {
+      // React does not re-send an unchanged text prop, so a count-only
+      // acknowledgement that catches up must reapply the cached JS text.
+      guard acknowledgedEventCount != nil, canApplyJsUpdate,
+            let pending = lastJsText, pending != currentInputText else { return }
+      text = pending
+    }
+  }
+
+  // JS supplies the count as a Double; Int(_:) traps on NaN/infinity/
+  // out-of-range. Valid acknowledgements are exact, non-negative values in
+  // the Android Int range — identical to the Android sanitization, so the
+  // same prop value can never be stale on one platform and current on the
+  // other. Anything else degrades to uncounted (nil).
+  private var acknowledgedEventCount: Int? {
+    guard let acknowledged = mostRecentEventCount,
+          acknowledged.isFinite,
+          acknowledged >= 0,
+          acknowledged <= Double(Int32.max),
+          acknowledged.rounded(.down) == acknowledged
+    else { return nil }
+    return Int(acknowledged)
+  }
+
+  private var canApplyJsUpdate: Bool {
+    guard let acknowledged = acknowledgedEventCount else { return true }
+    return acknowledged >= nativeEventCount
+  }
+
+  private var currentInputText: String {
+    (multiline == true ? multiLineInput.text : singleLineInput.text) ?? ""
+  }
+
   var text: String? {
     didSet {
       guard !isUpdatingFromJS else { return }
+      lastJsText = text ?? ""
+      guard canApplyJsUpdate else {
+        // Stale controlled update: keep the freshly typed value and realign
+        // the stored prop with what is actually displayed. (Assigning here
+        // does not re-trigger didSet.)
+        text = currentInputText
+        return
+      }
       isUpdatingFromJS = true
       if multiline == true {
         multiLineInput.text = text ?? ""
@@ -547,6 +602,7 @@ class HybridAutoSizeInput: HybridAutoSizeInputSpec {
 
   fileprivate func handleTextFieldChange(_ textField: UITextField) {
     guard !isUpdatingFromJS else { return }
+    nativeEventCount += 1
     view.setNeedsLayout()
     recalculateFontSize()
     onChangeText?(textField.text ?? "")
@@ -554,6 +610,7 @@ class HybridAutoSizeInput: HybridAutoSizeInputSpec {
 
   fileprivate func handleTextViewChange(_ textView: UITextView) {
     guard !isUpdatingFromJS else { return }
+    nativeEventCount += 1
     view.setNeedsLayout()
     recalculateFontSize()
     onChangeText?(textView.text ?? "")

package/lib/nitrogen/generated/android/autosizeinput+autolinking.cmake

@@ -2,7 +2,7 @@
 # autosizeinput+autolinking.cmake
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2026 Marc Rousavy @ Margelo
+# Copyright © Marc Rousavy @ Margelo
 #
 
 # This is a CMake file that adds all files generated by Nitrogen

package/lib/nitrogen/generated/android/autosizeinput+autolinking.gradle

@@ -2,7 +2,7 @@
 /// autosizeinput+autolinking.gradle
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 /// This is a Gradle file that adds all files generated by Nitrogen

package/lib/nitrogen/generated/android/autosizeinputOnLoad.cpp

@@ -2,7 +2,7 @@
 /// autosizeinputOnLoad.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #ifndef BUILDING_AUTOSIZEINPUT_WITH_GENERATED_CMAKE_PROJECT
@@ -24,27 +24,37 @@
 namespace margelo::nitro::autosizeinput {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::autosizeinput::registerAllNatives();
+  });
+}
+
+struct JHybridAutoSizeInputSpecImpl: public jni::JavaClass<JHybridAutoSizeInputSpecImpl, JHybridAutoSizeInputSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/HybridAutoSizeInput;";
+  static std::shared_ptr<JHybridAutoSizeInputSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridAutoSizeInputSpecImpl::javaobject()>();
+    jni::local_ref<JHybridAutoSizeInputSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridAutoSizeInputSpec();
+  }
+};
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::autosizeinput;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    margelo::nitro::autosizeinput::JHybridAutoSizeInputSpec::registerNatives();
-    margelo::nitro::autosizeinput::JFunc_void_std__string_cxx::registerNatives();
-    margelo::nitro::autosizeinput::JFunc_void_cxx::registerNatives();
-    margelo::nitro::autosizeinput::views::JHybridAutoSizeInputStateUpdater::registerNatives();
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "AutoSizeInput",
-      []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridAutoSizeInputSpec::javaobject> object("com/margelo/nitro/autosizeinput/HybridAutoSizeInput");
-        auto instance = object.create();
-        return instance->cthis()->shared();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  margelo::nitro::autosizeinput::JHybridAutoSizeInputSpec::CxxPart::registerNatives();
+  margelo::nitro::autosizeinput::JFunc_void_std__string_cxx::registerNatives();
+  margelo::nitro::autosizeinput::JFunc_void_cxx::registerNatives();
+  margelo::nitro::autosizeinput::views::JHybridAutoSizeInputStateUpdater::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AutoSizeInput",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridAutoSizeInputSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::autosizeinput

package/lib/nitrogen/generated/android/autosizeinputOnLoad.hpp

@@ -2,24 +2,33 @@
 /// autosizeinputOnLoad.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::autosizeinput {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of autosizeinput, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of autosizeinput, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::autosizeinput::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all autosizeinput HybridObjects
+   *     margelo::nitro::autosizeinput::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::autosizeinput

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

@@ -2,7 +2,7 @@
 /// JFunc_void.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -23,7 +23,7 @@ namespace margelo::nitro::autosizeinput {
    */
   struct JFunc_void: public jni::JavaClass<JFunc_void> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void;";
 
   public:
     /**
@@ -59,7 +59,7 @@ namespace margelo::nitro::autosizeinput {
     }
 
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_cxx;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_cxx;";
     static void registerNatives() {
       registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
     }

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

@@ -2,7 +2,7 @@
 /// JFunc_void_std__string.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -24,7 +24,7 @@ namespace margelo::nitro::autosizeinput {
    */
   struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_std__string;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_std__string;";
 
   public:
     /**
@@ -60,7 +60,7 @@ namespace margelo::nitro::autosizeinput {
     }
 
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_std__string_cxx;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_std__string_cxx;";
     static void registerNatives() {
       registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
     }