@momo-kits/calculator-keyboard 0.150.2-beta.36 → 0.150.2-beta.37

package/android/src/main/java/com/calculatorkeyboard/CustomKeyboardView.kt

@@ -1,22 +1,19 @@
 package com.calculatorkeyboard
 
 import android.annotation.SuppressLint
-import android.content.Context
 import android.content.res.ColorStateList
 import android.graphics.Color
 import android.graphics.drawable.GradientDrawable
+import android.text.Editable
 import android.view.Gravity
 import android.widget.Button
+import android.widget.EditText
 import android.widget.ImageButton
 import androidx.constraintlayout.widget.ConstraintLayout
-import com.facebook.react.uimanager.ThemedReactContext
-import org.mariuszgromada.math.mxparser.Expression
 import androidx.core.graphics.toColorInt
 import com.calculatorkeyboard.InputCalculatorViewManager.Companion.calculatorHeight
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.facebook.react.uimanager.ThemedReactContext
+import org.mariuszgromada.math.mxparser.Expression
 
 @SuppressLint("SetTextI18n", "ViewConstructor")
 class CustomKeyboardView(
@@ -170,27 +167,77 @@ class CustomKeyboardView(
     }
   }
 
+  private fun String.endsWithAny(vararg tails: String): Boolean =
+    tails.any { endsWith(it) }
+
+  private fun Editable.insertAtCaret(editText: EditText, s: String) {
+    insert(editText.selectionStart.coerceAtLeast(0), s)
+  }
+
   private fun onKeyPress(key: String, isMainCTAKey: Boolean) {
     if (isMainCTAKey) {
-      emitCustomKey(context)
+      Event.emitCustomKey(context, editText.id)
       return
     }
 
-    emitKeyPress(context, key)
+    Event.emitKeyPress(context, editText.id, key)
+
+    val text = editText.text ?: return
+    val plain = text.toString()
+    val isEmpty = plain.isEmpty()
+    val isJustZero = plain == "0"
+    val endsWithOperator = plain.endsWithAny(" + ", " - ", " × ", " ÷ ")
+    val endsWithSingleZeroAfterOp = plain.endsWith(" 0")
+
     when (key) {
       "AC" -> clearText()
       "back" -> onBackSpace()
       "=" -> calculateResult()
-      "×", "+", "-", "÷" -> keyDidPress(" $key ")
-      else -> editText.text?.insert(editText.selectionStart, key)
+      "×", "+", "-", "÷" -> if (!text.isEmpty()) keyDidPress(" $key ")
+      "0", "000" -> {
+        when {
+          isEmpty -> {}
+          key == "000" && endsWithOperator -> text.insertAtCaret(editText, "0")
+          endsWithSingleZeroAfterOp || isJustZero -> {}
+          else -> text.insertAtCaret(editText, key)
+        }
+      }
+      else -> {
+        when {
+          isJustZero -> {
+            text.replace(0, 1, key)
+          }
+          endsWithSingleZeroAfterOp -> {
+            val i = text.length - 1
+            text.replace(i, i + 1, key)
+          }
+          else -> text.insertAtCaret(editText, key)
+        }
+      }
     }
 
     reformatAndKeepSelection(editText)
   }
 
   private fun keyDidPress(key: String) {
-    println("Key pressed: $key")
-    editText.text?.replace(editText.selectionStart, editText.selectionEnd, key)
+    val editable = editText.text ?: return
+    val selStart = editText.selectionStart.coerceAtLeast(0)
+    val selEnd = editText.selectionEnd.coerceAtLeast(selStart)
+
+    if (selStart != selEnd) {
+      editable.replace(selStart, selEnd, key)
+      return
+    }
+
+    val s = editable.toString()
+    val ops3 = setOf(" + ", " - ", " × ", " ÷ ")
+
+    if (selStart >= 3 && ops3.contains(s.substring(selStart - 3, selStart))) {
+      editable.replace(selStart - 3, selStart, key)
+      return
+    }
+
+    editable.replace(selStart, selEnd, key)
   }
 
   private fun clearText() {
@@ -206,67 +253,77 @@ class CustomKeyboardView(
 
     if (caretRaw <= 0) return
 
-    val rawAfter = buildString(rawBefore.length - 1) {
-      append(rawBefore, 0, caretRaw - 1)
-      append(rawBefore, caretRaw, rawBefore.length)
+    val ops = setOf(" + ", " - ", " × ", " ÷ ")
+    val len = rawBefore.length
+
+    var delStart = (caretRaw - 1).coerceAtLeast(0)
+    var delEnd   = caretRaw
+
+    fun matches(start: Int, end: Int): Boolean {
+      if (start < 0 || end > len) return false
+      if (end - start != 3) return false
+      return ops.contains(rawBefore.substring(start, end))
+    }
+
+    if (matches(caretRaw - 3, caretRaw)) {
+      delStart = caretRaw - 3
+      delEnd   = caretRaw
+    }
+    else if (matches(caretRaw - 2, caretRaw + 1)) {
+      delStart = caretRaw - 2
+      delEnd   = caretRaw + 1
+    }
+    else if (matches(caretRaw - 1, caretRaw + 2)) {
+      delStart = caretRaw - 1
+      delEnd   = caretRaw + 2
+    }
+
+    val rawAfter = buildString(len - (delEnd - delStart)) {
+      append(rawBefore, 0, delStart)
+      append(rawBefore, delEnd, len)
     }
 
     val formattedAfter = formatNumberGroups(rawAfter)
     editText.setText(formattedAfter)
-    val newCaretFmt = rawCaretToFormatted(caretRaw - 1, formattedAfter)
+
+    val newCaretFmt = rawCaretToFormatted(delStart, formattedAfter)
     editText.setSelection(newCaretFmt.coerceIn(0, formattedAfter.length))
   }
 
-
-  private fun calculateResult() {
-    val raw = editText.text?.toString().orEmpty()
-    val normalized = raw.replace(".", "")
-      .replace("×", "*")
-      .replace("÷", "/")
-
-    val pattern = "^\\s*(-?\\d+(\\.\\d+)?\\s*[-+*/]\\s*)*-?\\d+(\\.\\d+)?\\s*$"
-    if (Regex(pattern).matches(normalized)) {
-      try {
-        val result = eval(normalized)?.toString() ?: return
-        editText.setTextKeepState(formatNumberGroups(result))
-        editText.setSelection(editText.text?.length ?: 0)
-      } catch (_: Exception) { /* ignore */ }
-    } else {
-      println("Invalid expression")
-    }
+  private fun calculateResult(){
+    val result = editText.calculate()
+    if (result == "invalid") return
+    editText.setTextKeepState(formatNumberGroups(result))
+    editText.setSelection(editText.text?.length ?: 0)
   }
 
-  private fun eval(str: String): Long? {
-    val e = Expression(str)
-    println("Expression: $e")
-    return if (e.checkSyntax()) {
-      e.calculate().toLong()
-    } else {
-      null
+  fun formatNumberGroups(input: String): String {
+    val noSep = stripGroupDots(input)
+    return Regex("\\d+").replace(noSep) { m ->
+      val s = m.value
+      val rev = s.reversed().chunked(3).joinToString(".")
+      rev.reversed()
     }
   }
 
-  private fun emitKeyPress(context: Context, key: String) {
-    val reactContext = context as ReactContext
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
-    val payload =
-      Arguments.createMap().apply {
-        putString("key", key)
-      }
-    val event = OnKeyPressEvent(surfaceId, editText.id, payload)
 
-    eventDispatcher?.dispatchEvent(event)
+  fun stripGroupDots(input: String): String {
+    val out = StringBuilder(input.length)
+    for (i in input.indices) {
+      val c = input[i]
+      if (c == '.' && isGroupDotAt(input, i)) {
+      } else {
+        out.append(c)
+      }
+    }
+    return out.toString()
   }
-
-  private fun emitCustomKey(context: Context) {
-    val reactContext = context as ReactContext
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
-
-    val event = OnCustomKeyPressEvent(surfaceId, editText.id)
-
-    eventDispatcher?.dispatchEvent(event)
+  private fun isGroupDotAt(s: String, i: Int): Boolean {
+    if (i < 0 || i >= s.length) return false
+    if (s[i] != '.') return false
+    val leftIsDigit  = i - 1 >= 0 && s[i - 1].isDigit()
+    val rightIsDigit = i + 1 < s.length && s[i + 1].isDigit()
+    return leftIsDigit && rightIsDigit
   }
 
   fun setCustomKeyText(text: String) {
@@ -304,7 +361,7 @@ class CustomKeyboardView(
     customKeyButton?.setTextColor(textColor)
   }
 
-  private fun reformatAndKeepSelection(editText: CalculatorEditText) {
+  fun reformatAndKeepSelection(editText: CalculatorEditText) {
     val formattedBefore = editText.text?.toString() ?: return
     val caretFmtBefore = editText.selectionStart.coerceAtLeast(0)
 
@@ -319,34 +376,6 @@ class CustomKeyboardView(
     val caretFmtAfter = rawCaretToFormatted(caretRaw, formattedAfter)
     editText.setSelection(caretFmtAfter.coerceIn(0, formattedAfter.length))
   }
-  private fun stripGroupDots(input: String): String {
-    val out = StringBuilder(input.length)
-    for (i in input.indices) {
-      val c = input[i]
-      if (c == '.' && isGroupDotAt(input, i)) {
-      } else {
-        out.append(c)
-      }
-    }
-    return out.toString()
-  }
-
-  private fun formatNumberGroups(input: String): String {
-    val noSep = stripGroupDots(input)
-    return Regex("\\d+").replace(noSep) { m ->
-      val s = m.value
-      val rev = s.reversed().chunked(3).joinToString(".")
-      rev.reversed()
-    }
-  }
-
-  private fun isGroupDotAt(s: String, i: Int): Boolean {
-    if (i < 0 || i >= s.length) return false
-    if (s[i] != '.') return false
-    val leftIsDigit  = i - 1 >= 0 && s[i - 1].isDigit()
-    val rightIsDigit = i + 1 < s.length && s[i + 1].isDigit()
-    return leftIsDigit && rightIsDigit
-  }
 
   private fun formattedCaretToRaw(formatted: String, caretFmt: Int): Int {
     var rawIdx = 0
@@ -374,4 +403,33 @@ class CustomKeyboardView(
     }
     return formatted.length
   }
+
+  companion object {
+    fun CalculatorEditText.calculate() : String {
+      val invalid = "invalid"
+      val raw = this.text?.toString().orEmpty()
+      val normalized = raw.replace(".", "")
+        .replace("×", "*")
+        .replace("÷", "/")
+
+      val pattern = "^\\s*(-?\\d+(\\.\\d+)?\\s*[-+*/]\\s*)*-?\\d+(\\.\\d+)?\\s*$"
+      if (Regex(pattern).matches(normalized)) {
+        try {
+          val result = eval(normalized)?.toString() ?: return invalid
+          return result
+        } catch (_: Exception) { return invalid }
+      } else {
+        return invalid
+      }
+    }
+    private fun eval(str: String): Long? {
+      val e = Expression(str)
+      println("Expression: $e")
+      return if (e.checkSyntax()) {
+        e.calculate().toLong()
+      } else {
+        null
+      }
+    }
+  }
 }

package/android/src/main/java/com/calculatorkeyboard/Event.kt

@@ -1,6 +1,10 @@
 package com.calculatorkeyboard
 
+import android.content.Context
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
 
 class OnChangeEvent(
@@ -17,20 +21,109 @@ class OnKeyPressEvent(
   surfaceId: Int,
   viewId: Int,
   private val payload: WritableMap
-) : Event<OnChangeEvent>(surfaceId, viewId) {
+) : Event<OnKeyPressEvent>(surfaceId, viewId) {
   override fun getEventName() = "onKeyPress"
 
   override fun getEventData() = payload
 }
 
+class OnResultEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val payload: WritableMap
+) : Event<OnResultEvent>(surfaceId, viewId) {
+  override fun getEventName() = "onResult"
+
+  override fun getEventData() = payload
+}
+
+class OnFocusEvent(
+  surfaceId: Int,
+  viewId: Int
+) : Event<OnFocusEvent>(surfaceId, viewId) {
+  override fun getEventName() = "onFocus"
+
+  override fun getEventData() = null
+}
+
+class OnBlurEvent(
+  surfaceId: Int,
+  viewId: Int
+) : Event<OnBlurEvent>(surfaceId, viewId) {
+  override fun getEventName() = "onBlur"
+
+  override fun getEventData() = null
+}
+
 class OnCustomKeyPressEvent(
   surfaceId: Int,
   viewId: Int
-) : Event<OnChangeEvent>(surfaceId, viewId) {
+) : Event<OnCustomKeyPressEvent>(surfaceId, viewId) {
   override fun getEventName() = "onCustomKeyEvent"
 
   override fun getEventData() = null
 }
 
+object Event {
+  fun emitKeyPress(context: Context, tag: Int, key: String) {
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, tag)
+    val payload =
+      Arguments.createMap().apply {
+        putString("key", key)
+      }
+    val event = OnKeyPressEvent(surfaceId, tag, payload)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  fun emitCustomKey(context: Context, tag: Int) {
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, tag)
+
+    val event = OnCustomKeyPressEvent(surfaceId, tag)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  fun emitOnChange(context: Context, tag: Int, text: String) {
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, tag)
+    val payload =
+      Arguments.createMap().apply {
+        putString("text", text)
+      }
+    val event = OnChangeEvent(surfaceId, tag, payload)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  fun emitOnBlurFocus(context: Context, tag: Int, isFocus: Boolean) {
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, tag)
+
+    val event = if (isFocus) OnFocusEvent(surfaceId, tag) else OnBlurEvent(surfaceId, tag)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  fun emitOnResult(context: Context, tag: Int, result: String) {
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, tag)
+    val payload =
+      Arguments.createMap().apply {
+        putString("result", result)
+      }
+    val event = OnResultEvent(surfaceId, tag, payload)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+}
+
 
 

package/android/src/main/java/com/calculatorkeyboard/InputCalculatorViewManager.kt

@@ -5,7 +5,6 @@ import android.content.Context
 import android.graphics.Color
 import android.graphics.Typeface
 import android.os.Build
-import android.provider.Settings.Global.putString
 import android.text.Editable
 import android.text.TextWatcher
 import android.view.KeyEvent
@@ -13,24 +12,18 @@ import android.view.inputmethod.InputMethodManager
 import androidx.core.graphics.toColorInt
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
-import androidx.core.widget.addTextChangedListener
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.ReadableArray
+import com.calculatorkeyboard.CustomKeyboardView.Companion.calculateResult
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.uimanager.events.RCTEventEmitter
 import com.facebook.react.viewmanagers.NativeInputCalculatorManagerDelegate
 import com.facebook.react.viewmanagers.NativeInputCalculatorManagerInterface
 import com.facebook.react.views.textinput.ReactEditText
-import com.facebook.react.views.textinput.ReactTextInputManager
 
 @ReactModule(name = InputCalculatorViewManager.REACT_CLASS)
 class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInputCalculatorManagerInterface<ReactEditText> {
@@ -67,12 +60,15 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
       val atEnd = wasFocused && view.selectionStart == e.length && view.selectionEnd == e.length
       e.replace(0, e.length, newText)
       if (!wasFocused || atEnd) view.setSelection(newText.length)
+      keyboardView?.reformatAndKeepSelection(editText)
     }
   }
 
   override fun setTextAttributes(view: ReactEditText?, value: ReadableMap?) {
     val fontWeightStr = value?.getString("fontWeight")
     val fontSize = value?.getDouble("fontSize")
+    val placeHolder = value?.getString("placeholder")
+    val placeHolderTextColor = value?.getString("placeholderTextColor")
 
     fontWeightStr?.let { weightStr ->
       val weight = when (weightStr) {
@@ -102,6 +98,12 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
     fontSize?.let {
       view?.textSize = it.toFloat()
     }
+    placeHolder?.let {
+      view?.setPlaceholder(placeHolder)
+    }
+    placeHolderTextColor?.let {
+      view?.setHintTextColor(it.toColorInt())
+    }
   }
 
 
@@ -145,6 +147,8 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
     editText = CalculatorEditText(context).apply {
       showSoftInputOnFocus = false
       isFocusableInTouchMode = true
+      isSingleLine = true
+
       setOnTouchListener { v, event ->
         if (event.action == android.view.MotionEvent.ACTION_DOWN) {
           showSoftInputOnFocus = false
@@ -172,10 +176,15 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
         override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
 
         override fun afterTextChanged(s: Editable?) {
-          emitOnChange(context, s.toString())
+          Event.emitOnChange(context, editText.id, s.toString())
+          Event.emitOnResult(context, editText.id, editText.calculateResult())
         }
 
       })
+
+      setOnFocusChangeListener { view, hasFocus ->
+        Event.emitOnBlurFocus(context, editText.id, hasFocus)
+      }
     }
 
     keyboardView = CustomKeyboardView(context, editText).apply {
@@ -230,7 +239,7 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
 
   private fun disableSystemImeFor(v: ReactEditText) {
     v.showSoftInputOnFocus = false
-    if (android.os.Build.VERSION.SDK_INT >= 30) {
+    if (Build.VERSION.SDK_INT >= 30) {
       ViewCompat.getWindowInsetsController(v)?.hide(WindowInsetsCompat.Type.ime())
     }
     imm.hideSoftInputFromWindow(v.windowToken, 0)
@@ -240,28 +249,18 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
     v.showSoftInputOnFocus = true
   }
 
-  private fun emitOnChange(context: Context, text: String) {
-    val reactContext = context as ReactContext
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
-    val payload =
-      Arguments.createMap().apply {
-        putString("text", text)
-      }
-    val event = OnChangeEvent(surfaceId, editText.id, payload)
-
-    eventDispatcher?.dispatchEvent(event)
-  }
-
   override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
     val base = super.getExportedCustomBubblingEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
     base["onKeyPress"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onKeyPress"))
     base["onChange"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onChange"))
+    base["onResult"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onResult"))
     return base
   }
 
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
     val base = super.getExportedCustomDirectEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
+    base["onBlur"] = mapOf("registrationName" to "onBlur")
+    base["onFocus"] = mapOf("registrationName" to "onFocus")
     base["onCustomKeyEvent"] = mapOf("registrationName" to "onCustomKeyEvent")
     return base
   }

package/ios/CalculatorKeyboardView.h

@@ -6,7 +6,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)keyDidPress:(NSString *)key;
 - (void)clearText;
+- (NSString *)getText;
 - (void)onBackSpace;
+- (NSString *)calculate;
 - (void)calculateResult;
 - (void)emitCustomKey;
 - (void)emitKeyPress:(NSString *)key;

package/ios/CalculatorKeyboardView.mm

@@ -1,4 +1,5 @@
 #import "CalculatorKeyboardView.h"
+#import "Utils.h"
 
 @interface CalculatorKeyboardView ()
 @property (nonatomic, strong) NSArray<NSArray<NSString *> *> *numWithCTAKeys;
@@ -82,7 +83,7 @@
     [subview removeFromSuperview];
   }
   
-  self.backgroundColor = [self colorFromHex:@"#f2f2f6"];
+  self.backgroundColor = [Utils colorFromHex:@"#f2f2f6"];
   
   CGFloat buttonWidth = (UIScreen.mainScreen.bounds.size.width - _separatorWidth * 2 - 4 * _separatorWidth) / 5;
   CGFloat buttonHeight = (240 - _separatorWidth * 2 - 3 * _separatorWidth) / 4;
@@ -143,7 +144,7 @@
       
       if ([_specialKeys containsObject:key] || isMainKey) {
         [button setTitleColor:UIColor.blackColor forState:UIControlStateNormal];
-        button.backgroundColor = [self colorFromHex:@"#d8d8d8"];
+        button.backgroundColor = [Utils colorFromHex:@"#d8d8d8"];
       }
       
       if (isMainKey) {
@@ -181,51 +182,93 @@
     self.customKeyButton.enabled = YES;
   }
   
-  self.customKeyButton.backgroundColor = [self colorFromHex:_customKeyBackground];
-  [self.customKeyButton setTitleColor:[self colorFromHex:_customKeyTextColor] forState:UIControlStateNormal];
+  self.customKeyButton.backgroundColor = [Utils colorFromHex:_customKeyBackground];
+  [self.customKeyButton setTitleColor:[Utils colorFromHex:_customKeyTextColor] forState:UIControlStateNormal];
 }
 
 - (void)keyPressed:(UIButton *)sender
 {
   NSString *key = sender.accessibilityIdentifier;
-  if (!key) {
-    return;
-  }
-  
-  BOOL isCustomKeyCTA = (sender.tag == 1);
-  if (isCustomKeyCTA) {
+  if (!key) return;
+
+  if (sender.tag == 1) {
     [self.input emitCustomKey];
     return;
   }
   
   [self.input emitKeyPress:key];
-  
+
+  NSString *text = self.input.getText ?: @"";
+  BOOL isEmpty = (text.length == 0);
+  BOOL isJustZero = [text isEqualToString:@"0"];
+
+  BOOL endsWithPlus  = [text hasSuffix:@" + "];
+  BOOL endsWithMinus = [text hasSuffix:@" - "];
+  BOOL endsWithMul   = [text hasSuffix:@" × "];
+  BOOL endsWithDiv   = [text hasSuffix:@" ÷ "];
+  BOOL endsWithOperator = (endsWithPlus || endsWithMinus || endsWithMul || endsWithDiv);
+
+  BOOL endsWithSingleZeroAfterOp = [text hasSuffix:@" 0"];
+
+  BOOL (^isOpKey)(NSString *) = ^BOOL(NSString *k) {
+    return [k isEqualToString:@"+"] || [k isEqualToString:@"-"] ||
+           [k isEqualToString:@"×"] || [k isEqualToString:@"÷"];
+  };
+  void (^insert)(NSString *) = ^(NSString *s) { [self.input keyDidPress:s]; };
+  void (^replaceTrailingZeroWith)(NSString *) = ^(NSString *s) {
+    [self.input onBackSpace];
+    [self.input keyDidPress:s];
+  };
+  void (^replaceAllWith)(NSString *) = ^(NSString *s) {
+    [self.input clearText];
+    [self.input keyDidPress:s];
+  };
+
   if ([key isEqualToString:@"AC"]) {
     [self.input clearText];
-  } else if ([key isEqualToString:@"back"]) {
+    return;
+  }
+
+  if ([key isEqualToString:@"back"]) {
     [self.input onBackSpace];
-  } else if ([key isEqualToString:@"="]) {
+    return;
+  }
+
+  if ([key isEqualToString:@"="]) {
     [self.input calculateResult];
-  } else if ([key isEqualToString:@"+"] || [key isEqualToString:@"-"] || 
-             [key isEqualToString:@"÷"] || [key isEqualToString:@"×"]) {
-    [self.input keyDidPress:[NSString stringWithFormat:@" %@ ", key]];
+    return;
+  }
+
+  if (isOpKey(key)) {
+    if (!isEmpty) {
+      insert([NSString stringWithFormat:@" %@ ", key]);
+    }
+    return;
+  }
+
+  if ([key isEqualToString:@"0"] || [key isEqualToString:@"000"]) {
+    if (isEmpty) return;
+
+    if ([key isEqualToString:@"000"] && endsWithOperator) {
+      insert(@"0");
+      return;
+    }
+
+    if (endsWithSingleZeroAfterOp || isJustZero) return;
+
+    insert(key);
+    return;
+  }
+
+  if (isJustZero) {
+    replaceAllWith(key);
+  } else if (endsWithSingleZeroAfterOp) {
+    replaceTrailingZeroWith(key);
   } else {
-    [self.input keyDidPress:key];
+    insert(key);
   }
 }
 
-- (UIColor *)colorFromHex:(NSString *)hexString
-{
-  unsigned rgbValue = 0;
-  NSString *cleanHex = [hexString stringByReplacingOccurrencesOfString:@"#" withString:@""];
-  NSScanner *scanner = [NSScanner scannerWithString:cleanHex];
-  [scanner scanHexInt:&rgbValue];
-  
-  return [UIColor colorWithRed:((rgbValue & 0xFF0000) >> 16) / 255.0
-                         green:((rgbValue & 0x00FF00) >> 8) / 255.0
-                          blue:(rgbValue & 0x0000FF) / 255.0
-                         alpha:1.0];
-}
 
 @end
 

package/ios/NativeInputCalculator.mm

@@ -8,6 +8,8 @@
 #import <react/renderer/components/CalculatorKeyboardSpecs/Props.h>
 #import <react/renderer/components/CalculatorKeyboardSpecs/RCTComponentViewHelpers.h>
 
+#import "Utils.h"
+
 using namespace facebook::react;
 
 @interface NativeInputCalculator () <RCTNativeInputCalculatorViewProtocol>
@@ -38,12 +40,37 @@ using namespace facebook::react;
 
     // Set custom keyboard
     _textField.inputView = _keyboardView;
-
+    [self startObservingFocusNotifications];
+    
     [self addSubview:_textField];
   }
   return self;
 }
 
+- (void)startObservingFocusNotifications
+{
+  NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+  [nc addObserver:self selector:@selector(_didBeginEditing:)
+             name:UITextFieldTextDidBeginEditingNotification object:_textField];
+  [nc addObserver:self selector:@selector(_didEndEditing:)
+             name:UITextFieldTextDidEndEditingNotification object:_textField];
+}
+
+- (void)_didBeginEditing:(NSNotification *)notification
+{
+  [self emitFocus];
+}
+
+- (void)_didEndEditing:(NSNotification *)notification
+{
+  [self emitBlur];
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
 - (CGFloat)getBottomInset
 {
   UIWindow *window = UIApplication.sharedApplication.windows.firstObject;
@@ -68,6 +95,8 @@ using namespace facebook::react;
     if (![_lastValue isEqualToString:newValue]) {
       _textField.text = newValue;
       _lastValue = newValue;
+      [self reformatAndKeepSelection];
+      [self notifyTextChange];
     }
   }
 
@@ -102,6 +131,14 @@ using namespace facebook::react;
       CGFloat size = _textField.font ? _textField.font.pointSize : UIFont.systemFontSize;
       _textField.font = [UIFont systemFontOfSize:size weight:weight];
   }
+  
+  if (oldViewProps.textAttributes.placeholder != newViewProps.textAttributes.placeholder
+      || oldViewProps.textAttributes.placeholderTextColor != newViewProps.textAttributes.placeholderTextColor) {
+    _textField.attributedPlaceholder = [[NSAttributedString alloc] initWithString:RCTNSStringFromString(newViewProps.textAttributes.placeholder)
+                                                                      attributes:@{
+        NSForegroundColorAttributeName: [Utils colorFromHex:RCTNSStringFromString(newViewProps.textAttributes.placeholderTextColor)]
+    }];
+  }
 
   [super updateProps:props oldProps:oldProps];
 }
@@ -143,11 +180,35 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
 
 - (void)keyDidPress:(NSString *)key {
   UITextRange *sel = _textField.selectedTextRange;
-  if (sel) {
+  if (!sel) return;
+
+  NSArray<NSString *> *ops = @[ @" + ", @" - ", @" × ", @" ÷ " ];
+  BOOL isOperatorKey = [ops containsObject:key];
+
+  if (!sel.isEmpty) {
     [_textField replaceRange:sel withText:key];
   } else {
-    [_textField insertText:key];
+    NSInteger caret = [_textField offsetFromPosition:_textField.beginningOfDocument
+                                           toPosition:sel.start];
+    NSString *text = _textField.text ?: @"";
+
+    if (isOperatorKey && caret >= 3 && caret <= (NSInteger)text.length) {
+      NSString *last3 = [text substringWithRange:NSMakeRange(caret - 3, 3)];
+      if ([ops containsObject:last3]) {
+        UITextPosition *start = [_textField positionFromPosition:_textField.beginningOfDocument
+                                                         offset:(caret - 3)];
+        UITextPosition *end = [_textField positionFromPosition:_textField.beginningOfDocument
+                                                       offset:caret];
+        UITextRange *range = [_textField textRangeFromPosition:start toPosition:end];
+        [_textField replaceRange:range withText:key];
+      } else {
+        [_textField insertText:key];
+      }
+    } else {
+      [_textField insertText:key];
+    }
   }
+
   [self reformatAndKeepSelection];
   [self notifyTextChange];
 }
@@ -158,6 +219,11 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   [self notifyTextChange];
 }
 
+- (NSString *)getText
+{
+  return _textField.text;
+}
+
 - (void)onBackSpace {
   NSString *formatted = _textField.text ?: @"";
   if (formatted.length == 0) return;
@@ -170,13 +236,44 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   NSInteger caretRaw = [self formattedCaretToRaw:formatted caret:caretFmt];
   if (caretRaw <= 0) return;
 
+  NSArray<NSString *> *ops = @[ @" + ", @" - ", @" × ", @" ÷ " ];
+  NSInteger len = (NSInteger)rawBefore.length;
+
+  NSInteger delStart = MAX(caretRaw - 1, 0);
+  NSInteger delLen   = 1;
+
+  BOOL (^matches)(NSInteger, NSInteger) = ^BOOL(NSInteger start, NSInteger end) {
+    if (start < 0 || end > len) return NO;
+    if (end - start != 3) return NO;
+    NSString *sub = [rawBefore substringWithRange:NSMakeRange(start, 3)];
+    for (NSString *op in ops) {
+      if ([sub isEqualToString:op]) return YES;
+    }
+    return NO;
+  };
+
+  if (matches(caretRaw - 3, caretRaw)) {
+    delStart = caretRaw - 3;
+    delLen   = 3;
+  }
+  else if (matches(caretRaw - 2, caretRaw + 1)) {
+    delStart = caretRaw - 2;
+    delLen   = 3;
+  }
+  else if (matches(caretRaw - 1, caretRaw + 2)) {
+    delStart = caretRaw - 1;
+    delLen   = 3;
+  }
+
   NSMutableString *rawAfter = [rawBefore mutableCopy];
-  [rawAfter deleteCharactersInRange:NSMakeRange(caretRaw - 1, 1)];
+  if (delStart >= 0 && delStart + delLen <= (NSInteger)rawAfter.length) {
+    [rawAfter deleteCharactersInRange:NSMakeRange(delStart, delLen)];
+  }
 
   NSString *formattedAfter = [self formatNumberGroups:rawAfter];
   _textField.text = formattedAfter;
 
-  NSInteger newCaretFmt = [self rawCaretToFormatted:(caretRaw - 1) inFormatted:formattedAfter];
+  NSInteger newCaretFmt = [self rawCaretToFormatted:delStart inFormatted:formattedAfter];
   UITextPosition *pos = [_textField positionFromPosition:_textField.beginningOfDocument offset:newCaretFmt];
   if (pos) {
     _textField.selectedTextRange = [_textField textRangeFromPosition:pos toPosition:pos];
@@ -185,8 +282,9 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   [self notifyTextChange];
 }
 
-- (void)calculateResult {
+- (NSString *)calculate {
   NSString *text = _textField.text ?: @"";
+  NSString *invalid = @"invalid";
 
   text = [self stripGroupDots:text];
   text = [text stringByReplacingOccurrencesOfString:@"×" withString:@"*"];
@@ -196,23 +294,29 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:nil];
   if (![regex firstMatchInString:text options:0 range:NSMakeRange(0, text.length)]) {
     NSLog(@"Invalid expression");
-    return;
+    return invalid;
   }
 
   @try {
     NSExpression *expr = [NSExpression expressionWithFormat:text];
     id val = [expr expressionValueWithObject:nil context:nil];
     if ([val isKindOfClass:[NSNumber class]]) {
-      NSString *result = [(NSNumber *)val stringValue];
-      NSString *formatted = [self formatNumberGroups:result];
-      _textField.text = formatted;
+      return [(NSNumber *)val stringValue];
+    }
+  } @catch (__unused NSException *e) { return invalid; }
+  return invalid;
+}
 
-      UITextPosition *end = _textField.endOfDocument;
-      _textField.selectedTextRange = [_textField textRangeFromPosition:end toPosition:end];
+- (void)calculateResult {
+  NSString *result = [self calculate];
+  if ([result isEqual: @"invalid"]) return;
+  NSString *formatted = [self formatNumberGroups:result];
+  _textField.text = formatted;
 
-      [self notifyTextChange];
-    }
-  } @catch (__unused NSException *e) {  }
+  UITextPosition *end = _textField.endOfDocument;
+  _textField.selectedTextRange = [_textField textRangeFromPosition:end toPosition:end];
+
+  [self notifyTextChange];
 }
 
 - (void)emitCustomKey
@@ -224,6 +328,26 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   }
 }
 
+- (void)emitFocus
+{
+  printf("emitFocus.");
+  if (_eventEmitter) {
+    auto emitter = std::static_pointer_cast<const NativeInputCalculatorEventEmitter>(_eventEmitter);
+    NativeInputCalculatorEventEmitter::OnFocus event{};
+    emitter->onFocus(event);
+  }
+}
+
+- (void)emitBlur
+{
+  printf("emitBlur.");
+  if (_eventEmitter) {
+    auto emitter = std::static_pointer_cast<const NativeInputCalculatorEventEmitter>(_eventEmitter);
+    NativeInputCalculatorEventEmitter::OnBlur event{};
+    emitter->onBlur(event);
+  }
+}
+
 - (void)emitKeyPress:(NSString *)key
 {
   if (_eventEmitter) {
@@ -245,6 +369,13 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
       .text = std::string([_textField.text UTF8String])
     };
     emitter->onChange(event);
+
+    NSString *result = [self calculate];
+    NativeInputCalculatorEventEmitter::OnResult event1{
+      .result = std::string([result UTF8String])
+    };
+    emitter->onResult(event1);
+
   }
 }
 

package/ios/Utils.h

@@ -0,0 +1,10 @@
+//
+//  Utils.h
+//  Pods
+//
+//  Created by Phuc on 21/10/25.
+//
+
+@interface Utils : NSObject
++ (UIColor *)colorFromHex:(NSString *)hexString;
+@end

package/ios/Utils.mm

@@ -0,0 +1,25 @@
+//
+//  Utils.mm
+//  Pods
+//
+//  Created by Phuc on 21/10/25.
+//
+
+#import <UIKit/UIKit.h>
+#import <Utils.h>
+
+@implementation Utils
+
++ (UIColor *)colorFromHex:(NSString *)hexString
+{
+  unsigned rgbValue = 0;
+  NSString *cleanHex = [hexString stringByReplacingOccurrencesOfString:@"#" withString:@""];
+  NSScanner *scanner = [NSScanner scannerWithString:cleanHex];
+  [scanner scanHexInt:&rgbValue];
+  
+  return [UIColor colorWithRed:((rgbValue & 0xFF0000) >> 16) / 255.0
+                         green:((rgbValue & 0x00FF00) >> 8) / 255.0
+                          blue:(rgbValue & 0x0000FF) / 255.0
+                         alpha:1.0];
+}
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@momo-kits/calculator-keyboard",
-    "version": "0.150.2-beta.36",
+    "version": "0.150.2-beta.37",
     "description": "react native calculator keyboard",
     "main": "./src/index.tsx",
     "files": [

package/src/InputCalculatorNativeComponent.ts

@@ -26,9 +26,15 @@ export type OnChangeEvent = Readonly<{
   text: string;
 }>;
 
+export type OnResultEvent = Readonly<{
+  result: string;
+}>;
+
 export type TextAttributes = Readonly<{
-  fontSize?: CodegenTypes.Float;
-  fontWeight?: string;
+  fontSize?: CodegenTypes.Float | undefined;
+  fontWeight?: string | undefined;
+  placeholder?: string | undefined;
+  placeholderTextColor?: string | undefined;
 }>;
 
 export interface NativeInputCalculatorProps extends ViewProps {
@@ -41,6 +47,9 @@ export interface NativeInputCalculatorProps extends ViewProps {
   customKeyState?: string;
   onChange?: CodegenTypes.BubblingEventHandler<OnChangeEvent>;
   onKeyPress?: CodegenTypes.BubblingEventHandler<OnKeyPressEvent>;
+  onResult?: CodegenTypes.BubblingEventHandler<OnResultEvent>;
+  onBlur?: CodegenTypes.BubblingEventHandler<{}>;
+  onFocus?: CodegenTypes.BubblingEventHandler<{}>;
   onCustomKeyEvent?: CodegenTypes.DirectEventHandler<{}>;
 }
 

package/src/index.tsx

@@ -9,6 +9,7 @@ import {
   TextStyle,
 } from 'react-native';
 import NativeInputCalculator, {
+  OnResultEvent,
   TextAttributes,
 } from './InputCalculatorNativeComponent';
 import { Commands } from './InputCalculatorNativeComponent';
@@ -20,12 +21,17 @@ type KeyPressEvent = { nativeEvent: { key: string } };
 interface InputCalculatorProps extends TextInputProps {
   text?: string | undefined;
   mode?: Mode;
+  onBlur?: () => void;
+  onFocus?: () => void;
+  onResult?: (e: OnResultEvent) => void;
   onKeyPress?: (e: KeyPressEvent) => void;
   customKeyText?: string | undefined;
   customKeyBackground?: CustomKeyBackground;
   customKeyState?: CustomKeyState;
   onCustomKeyEvent?: () => void;
   style?: StyleProp<TextStyle>;
+  placeholder?: string | undefined;
+  placeholderTextColor?: string | undefined;
 }
 
 export type CustomKeyBackground = 'primary' | 'default' | string;
@@ -54,13 +60,17 @@ function isEmpty(obj: object | undefined | null) {
   return !obj || Object.keys(obj).length === 0;
 }
 
-export function styleToTextAttributes(
+function styleToTextAttributes(
   style?: StyleProp<TextStyle>,
+  placeholder?: string,
+  placeholderTextColor?: string,
 ): Readonly<TextAttributes> {
   const s = StyleSheet.flatten(style) ?? {};
   const attrs: TextAttributes = {
     fontSize: s.fontSize ?? undefined,
     fontWeight: (s.fontWeight as TextAttributes['fontWeight']) ?? undefined,
+    placeholder,
+    placeholderTextColor,
   };
   return Object.freeze(omitUndefined(attrs));
 }
@@ -74,6 +84,9 @@ const InputCalculator = React.forwardRef<
       customKeyBackground = 'default',
       mode = Mode.NumDefault,
       customKeyText,
+      onBlur,
+      onFocus,
+      onResult,
       onKeyPress,
       customKeyState = CustomKeyState.Default,
       onCustomKeyEvent,
@@ -117,8 +130,8 @@ const InputCalculator = React.forwardRef<
     }));
 
     const derivedTA = React.useMemo(
-      () => styleToTextAttributes(style),
-      [style],
+      () => styleToTextAttributes(style, props.placeholder, props.placeholderTextColor),
+      [style, props.placeholder, props.placeholderTextColor],
     );
 
     return (
@@ -128,6 +141,9 @@ const InputCalculator = React.forwardRef<
         textAttributes={isEmpty(derivedTA) ? undefined : derivedTA}
         ref={nativeRef}
         onChange={_onChange}
+        onBlur={onBlur}
+        onFocus={onFocus}
+        onResult={onResult}
         onKeyPress={onKeyPress}
         value={text}
         mode={mode}