@azsxdc12356/react-native-sync-format-edittext 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 azsxdc12356
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# react-native-sync-format-edittext
+
+React Native 同步格式化输入框 — 无闪烁的实时文本格式化
+
+## 功能介绍
+
+在 React Native 中对 TextInput 做实时格式化（如手机号 `138-0013-8000`），通常需要监听 `onChangeText`，在 JS 层格式化后再通过 `value` 回写。这个过程中文本要经过异步桥接往返，导致输入时出现明显的闪烁和光标跳动。
+
+本库通过 **JSI 同步调用**，让原生层在文本变化时直接同步调用 JS 的格式化函数，格式化结果立即生效，彻底消除闪烁。同时继承自原生 TextInput，支持所有原生 props。
+
+### 平台支持
+
+| 平台 | 状态 |
+|---|---|
+| Android | ✅ 已支持 |
+| iOS | 🚧 开发中 |
+
+## 演示效果
+
+**原生 TextInput 格式化 — 闪烁明显**
+
+![原生格式化](./docs/native-format.gif)
+
+**SyncFormatEditText — 无闪烁**
+
+![同步格式化](./docs/sync-format.gif)
+
+## 安装
+
+```sh
+npm install @azsxdc12356/react-native-sync-format-edittext
+```
+
+支持新架构和旧架构，autolink 自动完成链接。
+
+## 使用
+
+```tsx
+import { SyncFormatEdittextView } from '@azsxdc12356/react-native-sync-format-edittext';
+
+// 只允许输入数字
+function formatDigits(text: string, cursorPos: number) {
+  const digits = text.replace(/\D/g, '');
+  const removedBeforeCursor = text.slice(0, cursorPos).replace(/\d/g, '').length;
+  return {
+    text: digits,
+    cursorPos: cursorPos - removedBeforeCursor,
+  };
+}
+
+<SyncFormatEdittextView
+  value={code}
+  format={formatDigits}
+  onChangeText={setCode}
+  placeholder="请输入验证码"
+  style={styles.input}
+/>
+```
+
+## API
+
+### Props
+
+继承所有 `TextInputProps`，额外支持以下 props：
+
+| Prop | 类型 | 说明 |
+|---|---|---|
+| `format` | `(text: string, cursorPos: number) => { text: string; cursorPos: number }` | 格式化函数，接收当前文本和光标位置，返回格式化后的文本和调整后的光标位置 |
+| `onSyncFormatChange` | `(text: string, cursorPos: number) => void` | 格式化完成后的回调，返回格式化后的文本和光标位置 |
+
+### `format` 函数详解
+
+`cursorPos` 是字符在字符串中的索引（从 0 开始）。格式化后文本长度可能改变，光标位置需要相应调整，否则会跳到错误位置。
+
+**原理**：`cursorPos` 表示"光标在第几个字符前面"。格式化后，你需要计算光标在格式化文本中的对应位置。如果格式化只是过滤字符（文本变短），光标位置 = 原位置 - 光标前被过滤掉的字符数；如果格式化插入了分隔符（文本变长），还需要再加上光标前新增的分隔符数量。
+
+**示例 1：只过滤，不插入字符**
+
+输入 `a1b2`，光标在末尾（cursorPos=4）。过滤非数字后得到 `12`，光标前被过滤了 2 个字符，所以 cursorPos=4-2=2。
+
+```ts
+function formatDigits(text: string, cursorPos: number) {
+  const digits = text.replace(/\D/g, '');
+  const removedBeforeCursor = text.slice(0, cursorPos).replace(/\d/g, '').length;
+  return {
+    text: digits,
+    cursorPos: cursorPos - removedBeforeCursor,
+  };
+}
+```
+
+过滤不改变字符顺序，光标位置 = 原位置 - 光标前被过滤掉的字符数。
+
+**示例 2：插入分隔符**
+
+输入 `1380013`，光标在末尾（cursorPos=7）。格式化为 `138-0013`，光标前多了一个 `-`，所以 cursorPos=8。
+
+```ts
+function formatPhone(text: string, cursorPos: number) {
+  const beforeCursor = text.slice(0, cursorPos);
+  const removedBeforeCursor = beforeCursor.replace(/\d/g, '').length;
+  const adjustedPos = cursorPos - removedBeforeCursor;
+
+  const digits = text.replace(/\D/g, '').slice(0, 11);
+  let formatted = '';
+  let newCursorPos = adjustedPos;
+  if (digits.length <= 3) {
+    formatted = digits;
+  } else if (digits.length <= 7) {
+    formatted = `${digits.slice(0, 3)}-${digits.slice(3)}`;
+    if (adjustedPos > 3) newCursorPos = adjustedPos + 1;
+  } else {
+    formatted = `${digits.slice(0, 3)}-${digits.slice(3, 7)}-${digits.slice(7)}`;
+    if (adjustedPos > 3) newCursorPos = adjustedPos + 1;
+    if (adjustedPos > 7) newCursorPos = adjustedPos + 2;
+  }
+  return {
+    text: formatted,
+    cursorPos: Math.min(newCursorPos, formatted.length),
+  };
+}
+```
+
+关键逻辑：先用 `cursorPos - removedBeforeCursor` 得到纯数字中的位置，再根据分隔符偏移。光标每跨过一个分隔符位置，`cursorPos` 就 +1。
+
+更多示例参见 [example](./example/src/App.tsx)。
+
+## License
+
+MIT

package/SyncFormatEdittext.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "SyncFormatEdittext"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/junjie-z666/react-native-sync-format-edittext.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,105 @@
+buildscript {
+  ext.SyncFormatEdittext = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return SyncFormatEdittext[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.syncformatedittext"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        arguments "-DANDROID_STL=c++_shared"
+      }
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    if (rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true") {
+      main.java.srcDirs += "src/newarch/java"
+    } else {
+      main.java.srcDirs += "src/oldarch/java"
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+    }
+  }
+
+  packaging {
+    jniLibs {
+      excludes += [
+        "**/libfbjni.so",
+        "**/libjsi.so",
+        "**/libhermes.so",
+        "**/libreactnativejni.so",
+        "**/libreactnative.so",
+        "**/libjscexecutor.so",
+        "**/libhermestooling.so",
+        "**/libfolly_runtime.so",
+        "**/libglog.so",
+        "**/libturbomodulejsijni.so"
+      ]
+    }
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.13)
+project(syncformatedittext)
+
+set(CMAKE_VERBOSE_MAKEFILE on)
+set(CMAKE_CXX_STANDARD 20)
+
+# Find React Native Prefab packages
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+
+# Source files
+add_library(syncformatedittext SHARED
+  FormatHostObject.cpp
+  FormatModuleJNI.cpp
+)
+
+target_include_directories(syncformatedittext PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(syncformatedittext
+  fbjni::fbjni
+  ReactAndroid::jsi
+  ReactAndroid::reactnative
+)
+
+target_compile_options(syncformatedittext PRIVATE -fvisibility=hidden)
+target_link_options(syncformatedittext PRIVATE "-Wl,-z,max-page-size=16384")

package/android/src/main/cpp/FormatHostObject.cpp

@@ -0,0 +1,117 @@
+#include "FormatHostObject.h"
+#include <sstream>
+#include <vector>
+
+namespace facebook::react {
+
+FormatHostObject* FormatHostObject::instance_ = nullptr;
+
+FormatHostObject::FormatHostObject(std::shared_ptr<CallInvoker> callInvoker)
+    : callInvoker_(std::move(callInvoker)) {}
+
+jsi::Value FormatHostObject::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
+  auto methodName = name.utf8(rt);
+
+  if (methodName == "setFormat") {
+    auto self = shared_from_this();
+    return jsi::Function::createFromHostFunction(
+        rt, name, 2,
+        [self](jsi::Runtime& rt, const jsi::Value&, const jsi::Value* args, size_t count) -> jsi::Value {
+          if (count < 2) {
+            throw jsi::JSError(rt, "setFormat requires 2 arguments: viewTag, formatFn");
+          }
+          int viewTag = static_cast<int>(args[0].asNumber());
+          auto fn = std::make_shared<jsi::Function>(args[1].asObject(rt).asFunction(rt));
+
+          std::lock_guard<std::mutex> lock(self->mutex_);
+          self->formatFns_[viewTag] = std::move(fn);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "removeFormat") {
+    auto self = shared_from_this();
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [self](jsi::Runtime& rt, const jsi::Value&, const jsi::Value* args, size_t count) -> jsi::Value {
+          if (count < 1) {
+            throw jsi::JSError(rt, "removeFormat requires 1 argument: viewTag");
+          }
+          int viewTag = static_cast<int>(args[0].asNumber());
+          self->removeFormat(viewTag);
+          return jsi::Value::undefined();
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+void FormatHostObject::set(jsi::Runtime&, const jsi::PropNameID&, const jsi::Value&) {}
+
+void FormatHostObject::removeFormat(int viewTag) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  formatFns_.erase(viewTag);
+}
+
+bool FormatHostObject::hasFormat(int viewTag) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return formatFns_.find(viewTag) != formatFns_.end();
+}
+
+std::string FormatHostObject::formatText(int viewTag, const std::string& text, int cursorPos) {
+  // Copy shared_ptr OUTSIDE invokeSync to avoid deadlock
+  std::shared_ptr<jsi::Function> fnPtr;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = formatFns_.find(viewTag);
+    if (it != formatFns_.end()) {
+      fnPtr = it->second;
+    }
+  }
+  // mutex_ released here — JS thread won't block
+
+  if (!fnPtr) {
+    std::ostringstream oss;
+    oss << "{\"text\":\"" << text << "\",\"cursorPos\":" << cursorPos << "}";
+    return oss.str();
+  }
+
+  std::string resultJson;
+
+  callInvoker_->invokeSync([&resultJson, &text, cursorPos, fnPtr](jsi::Runtime& runtime) {
+    try {
+      auto result = fnPtr->call(runtime, {
+          jsi::String::createFromUtf8(runtime, text),
+          jsi::Value(cursorPos)});
+
+      if (result.isObject()) {
+        auto obj = result.asObject(runtime);
+        auto resultText = obj.getProperty(runtime, "text").asString(runtime).utf8(runtime);
+        auto resultCursor = static_cast<int>(obj.getProperty(runtime, "cursorPos").asNumber());
+
+        std::ostringstream oss;
+        oss << "{\"text\":\"";
+        for (char c : resultText) {
+          switch (c) {
+            case '"': oss << "\\\""; break;
+            case '\\': oss << "\\\\"; break;
+            case '\n': oss << "\\n"; break;
+            case '\r': oss << "\\r"; break;
+            case '\t': oss << "\\t"; break;
+            default: oss << c;
+          }
+        }
+        oss << "\",\"cursorPos\":" << resultCursor << "}";
+        resultJson = oss.str();
+      } else {
+        resultJson = "{\"text\":\"" + text + "\",\"cursorPos\":" + std::to_string(cursorPos) + "}";
+      }
+    } catch (...) {
+      resultJson = "{\"text\":\"" + text + "\",\"cursorPos\":" + std::to_string(cursorPos) + "}";
+    }
+  });
+
+  return resultJson;
+}
+
+} // namespace facebook::react

package/android/src/main/cpp/FormatHostObject.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <unordered_map>
+#include <string>
+#include <mutex>
+#include <memory>
+
+namespace facebook::react {
+
+class FormatHostObject : public jsi::HostObject,
+                         public std::enable_shared_from_this<FormatHostObject> {
+public:
+  FormatHostObject(std::shared_ptr<CallInvoker> callInvoker);
+  ~FormatHostObject() override { if (instance_ == this) instance_ = nullptr; }
+
+  jsi::Value get(jsi::Runtime& rt, const jsi::PropNameID& name) override;
+  void set(jsi::Runtime& rt, const jsi::PropNameID& name, const jsi::Value& value) override;
+
+  // Called from JNI (UI thread)
+  std::string formatText(int viewTag, const std::string& text, int cursorPos);
+  void removeFormat(int viewTag);
+  bool hasFormat(int viewTag);
+
+private:
+  std::shared_ptr<CallInvoker> callInvoker_;
+  // Use shared_ptr so we can copy out without holding lock during invokeSync
+  std::unordered_map<int, std::shared_ptr<jsi::Function>> formatFns_;
+  std::mutex mutex_;
+
+  static FormatHostObject* instance_;
+public:
+  static void setInstance(FormatHostObject* inst) { instance_ = inst; }
+  static FormatHostObject* getInstance() { return instance_; }
+};
+
+} // namespace facebook::react

package/android/src/main/cpp/FormatModuleJNI.cpp

@@ -0,0 +1,80 @@
+#include "FormatHostObject.h"
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/CallInvokerHolder.h>
+
+namespace facebook::react {
+
+static void installFormatModule(jsi::Runtime& runtime, const std::shared_ptr<CallInvoker>& callInvoker) {
+  auto hostObject = std::make_shared<FormatHostObject>(callInvoker);
+  FormatHostObject::setInstance(hostObject.get());
+
+  runtime.global().setProperty(
+      runtime,
+      "__formatModule",
+      jsi::Object::createFromHostObject(runtime, std::move(hostObject)));
+}
+
+} // namespace facebook::react
+
+extern "C" {
+
+JNIEXPORT void JNICALL
+Java_com_syncformatedittext_FormatModuleImpl_nativeInstall(
+    JNIEnv* env,
+    jclass clazz,
+    jlong jsiRuntimeRef,
+    jobject callInvokerHolder) {
+  auto runtime = reinterpret_cast<facebook::jsi::Runtime*>(jsiRuntimeRef);
+  auto invoker = facebook::jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>{
+      reinterpret_cast<facebook::react::CallInvokerHolder::javaobject>(callInvokerHolder)};
+  auto callInvoker = invoker->cthis()->getCallInvoker();
+  facebook::react::installFormatModule(*runtime, callInvoker);
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_syncformatedittext_FormatModuleImpl_nativeFormatText(
+    JNIEnv* env,
+    jclass clazz,
+    jint viewTag,
+    jstring text,
+    jint cursorPos) {
+  auto* instance = facebook::react::FormatHostObject::getInstance();
+  const char* textStr = env->GetStringUTFChars(text, nullptr);
+  std::string textCpp(textStr);
+  env->ReleaseStringUTFChars(text, textStr);
+
+  std::string result;
+  if (instance) {
+    result = instance->formatText(static_cast<int>(viewTag), textCpp, static_cast<int>(cursorPos));
+  } else {
+    result = "{\"text\":\"" + textCpp + "\",\"cursorPos\":" + std::to_string(cursorPos) + "}";
+  }
+
+  return env->NewStringUTF(result.c_str());
+}
+
+JNIEXPORT void JNICALL
+Java_com_syncformatedittext_FormatModuleImpl_nativeRemoveFormat(
+    JNIEnv* env,
+    jclass clazz,
+    jint viewTag) {
+  auto* instance = facebook::react::FormatHostObject::getInstance();
+  if (instance) {
+    instance->removeFormat(static_cast<int>(viewTag));
+  }
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_syncformatedittext_FormatModuleImpl_nativeHasFormat(
+    JNIEnv* env,
+    jclass clazz,
+    jint viewTag) {
+  auto* instance = facebook::react::FormatHostObject::getInstance();
+  if (!instance) return JNI_FALSE;
+  return instance->hasFormat(static_cast<int>(viewTag)) ? JNI_TRUE : JNI_FALSE;
+}
+
+} // extern "C"

package/android/src/main/java/com/syncformatedittext/FormatModuleImpl.kt

@@ -0,0 +1,77 @@
+package com.syncformatedittext
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+data class FormatResult(val text: String, val cursorPos: Int)
+
+class FormatModuleImpl(private val reactContext: ReactApplicationContext) {
+
+    fun install() {
+        if (!nativeLibLoaded) return
+        val runtimeRef = reactContext.javaScriptContextHolder!!.get()
+        val callInvokerHolder = reactContext.jsCallInvokerHolder!!
+        nativeInstall(runtimeRef, callInvokerHolder)
+    }
+
+    fun formatText(viewTag: Int, text: String, cursorPos: Int): FormatResult {
+        if (!nativeLibLoaded) return FormatResult(text, cursorPos)
+        val json = nativeFormatText(viewTag, text, cursorPos)
+        return parseFormatResult(json, text, cursorPos)
+    }
+
+    fun hasFormat(viewTag: Int): Boolean {
+        if (!nativeLibLoaded) return false
+        return nativeHasFormat(viewTag)
+    }
+
+    fun removeFormat(viewTag: Int) {
+        if (!nativeLibLoaded) return
+        nativeRemoveFormat(viewTag)
+    }
+
+    companion object {
+        @JvmStatic
+        var instance: FormatModuleImpl? = null
+
+        private var nativeLibLoaded = false
+
+        init {
+            try {
+                System.loadLibrary("syncformatedittext")
+                nativeLibLoaded = true
+            } catch (_: UnsatisfiedLinkError) {
+            }
+        }
+
+        @JvmStatic
+        external fun nativeInstall(runtimeRef: Long, callInvokerHolder: CallInvokerHolder)
+
+        @JvmStatic
+        external fun nativeFormatText(viewTag: Int, text: String, cursorPos: Int): String
+
+        @JvmStatic
+        external fun nativeRemoveFormat(viewTag: Int)
+
+        @JvmStatic
+        external fun nativeHasFormat(viewTag: Int): Boolean
+
+        private fun parseFormatResult(json: String, fallbackText: String, fallbackCursor: Int): FormatResult {
+            return try {
+                val textMatch = Regex("\"text\"\\s*:\\s*\"((?:[^\"\\\\]|\\\\.)*)\"").find(json)
+                val cursorMatch = Regex("\"cursorPos\"\\s*:\\s*(\\d+)").find(json)
+                val parsedText = textMatch?.groupValues?.get(1)
+                    ?.replace("\\\"", "\"")
+                    ?.replace("\\\\", "\\")
+                    ?.replace("\\n", "\n")
+                    ?.replace("\\r", "\r")
+                    ?.replace("\\t", "\t")
+                    ?: fallbackText
+                val parsedCursor = cursorMatch?.groupValues?.get(1)?.toIntOrNull() ?: fallbackCursor
+                FormatResult(parsedText, parsedCursor)
+            } catch (e: Exception) {
+                FormatResult(fallbackText, fallbackCursor)
+            }
+        }
+    }
+}

package/android/src/main/java/com/syncformatedittext/SyncFormatEdittextView.kt

@@ -0,0 +1,70 @@
+package com.syncformatedittext
+
+import android.content.Context
+import android.text.Editable
+import android.text.TextWatcher
+import android.util.Log
+import com.facebook.react.views.textinput.ReactEditText
+
+class SyncFormatEdittextView(context: Context) : ReactEditText(context) {
+  private var rawCursorPos = 0
+  private var isFormatting = false
+  private var lastFormattedText = ""
+  private var lastFormattedCursorPos = 0
+  private var onFormatListener: ((String, Int) -> Unit)? = null
+  var formatModule: FormatModuleImpl? = null
+
+  init {
+    addTextChangedListener(object : TextWatcher {
+      override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+      override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
+        if (isFormatting) return
+        rawCursorPos = if (count > 0) start + count else start
+      }
+      override fun afterTextChanged(s: Editable?) {
+        if (isFormatting) return
+        val currentText = s?.toString() ?: ""
+
+        // Skip if text matches our last formatted result (e.g. from JS value prop update)
+        if (currentText == lastFormattedText && selectionStart == lastFormattedCursorPos) {
+          onFormatListener?.invoke(currentText, lastFormattedCursorPos)
+          return
+        }
+
+        val module = formatModule
+        val viewTag = id
+
+        if (module != null && viewTag > 0 && module.hasFormat(viewTag)) {
+          try {
+            val result = module.formatText(viewTag, currentText, rawCursorPos)
+            if (result.text == currentText) {
+              val pos = result.cursorPos.coerceIn(0, currentText.length)
+              if (selectionStart != pos) {
+                setSelection(pos)
+              }
+              lastFormattedText = result.text
+              lastFormattedCursorPos = pos
+              onFormatListener?.invoke(result.text, pos)
+              return
+            }
+            val newCursorPos = result.cursorPos.coerceIn(0, result.text.length)
+            isFormatting = true
+            s?.replace(0, s.length, result.text)
+            setSelection(newCursorPos)
+            rawCursorPos = newCursorPos
+            isFormatting = false
+            lastFormattedText = result.text
+            lastFormattedCursorPos = newCursorPos
+            onFormatListener?.invoke(result.text, newCursorPos)
+          } catch (e: Exception) {
+            onFormatListener?.invoke(currentText, selectionEnd.coerceAtLeast(0))
+          }
+        }
+      }
+    })
+  }
+
+  fun setOnFormatListener(listener: (String, Int) -> Unit) {
+    onFormatListener = listener
+  }
+}