@momo-kits/calculator-keyboard 0.150.2-beta.22 → 0.150.2-beta.23

package/README.md

@@ -10,15 +10,57 @@ npm install react-native-calculator-keyboard
 
 ## Usage
 
-
 ```js
-import { CalculatorKeyboardView } from "react-native-calculator-keyboard";
+import InputCalculator from '@momo-kits/calculator-keyboard';
 
 // ...
 
-<CalculatorKeyboardView color="tomato" />
+<InputCalculator
+  mode="NumDefault"
+  customKeyText="Next"
+  onCustomKeyEvent={() => console.log('Custom key pressed')}
+/>;
+```
+
+## Requirements
+
+**React Native 0.80+** with **Fabric (New Architecture) enabled**.
+
+This library is **pure Fabric** implementation with:
+
+- ✅ Zero RCTBridge dependencies
+- ✅ Native C++ ComponentView on iOS
+- ✅ Fabric ViewManager with codegen delegates on Android
+- ✅ All Props, Events, Commands auto-generated by codegen
+- ❌ No Paper (old architecture) support
+
+### Android Setup
+
+Add to your `gradle.properties`:
+
+```properties
+newArchEnabled=true
+```
+
+Then rebuild:
+
+```bash
+cd android && ./gradlew clean && cd ..
+npx react-native run-android
+```
+
+### iOS Setup
+
+**Required**: Set the environment variable before installing pods:
+
+```bash
+cd ios
+RCT_NEW_ARCH_ENABLED=1 pod install
+cd ..
+npx react-native run-ios
 ```
 
+**Note**: This library uses Fabric ComponentView (`.mm` files) and will not work without `RCT_NEW_ARCH_ENABLED=1`.
 
 ## Contributing
 

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

@@ -12,6 +12,6 @@ class CalculatorKeyboardPackage : ReactPackage {
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return listOf(RCTInputCalculator())
+    return listOf(InputCalculatorViewManager())
   }
 }

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

@@ -1,19 +1,21 @@
 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.view.Gravity
 import android.widget.Button
 import android.widget.ImageButton
-import androidx.appcompat.app.AppCompatActivity
 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.RCTInputCalculator.Companion.calculatorHeight
+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
 
 @SuppressLint("SetTextI18n", "ViewConstructor")
@@ -21,53 +23,57 @@ class CustomKeyboardView(
   context: ThemedReactContext,
   private val editText: CalculatorEditText
 ) : ConstraintLayout(context) {
-  private val keys = listOf(
+  private val numWithCTAKeys = listOf(
     listOf("1", "2", "3", "÷", "back"),
     listOf("4", "5", "6", "×", "="),
-    listOf("7", "8", "9", "-", "Xong"),
+    listOf("7", "8", "9", "-", "Tiếp"),
     listOf("000", "0", "+")
   )
-  private val specialKeys = listOf("=", "-", "×", "÷", "back", "+")
+  private val defaultKeys = listOf(
+    listOf("1", "2", "3", "÷", "AC"),
+    listOf("4", "5", "6", "×", "back"),
+    listOf("7", "8", "9", "-", "="),
+    listOf("000", "0", "+")
+  )
+  private val specialKeys = listOf("=", "-", "×", "÷", "back", "+", "AC")
   private val separatorWidth = 8f
   private var specialButtonColor: Int = "#D8D8D8".toColorInt()
 
+  private var keyboardMode: String = "NumDefault"
+
   private var customKeyButton: Button? = null
   private var customKeyButtonBackground: Int = "#D8D8D8".toColorInt()
   private var customKeyButtonTextColor: Int = Color.BLACK
   private var customKeyButtonState: String = "default"
 
   init {
-    val activity = context.currentActivity as? AppCompatActivity
-    if (activity != null) {
-      val displayMetrics = resources.displayMetrics
-      val widthButton = (displayMetrics.widthPixels - separatorWidth * 2 - 4 * separatorWidth) / 5f
-      val heightButton = (calculatorHeight - separatorWidth * 2 - 3 * separatorWidth) / 4
-
       isClickable = false
       isFocusable = false
       isFocusableInTouchMode = false
       clipToPadding = false
       clipChildren = false
-
-      renderUI(widthButton, heightButton)
-    }
-
   }
 
-  private fun renderUI(buttonWidth: Float, buttonHeight: Float) {
+  private fun renderUI() {
+    val displayMetrics = resources.displayMetrics
+    val buttonWidth = (displayMetrics.widthPixels - separatorWidth * 2 - 4 * separatorWidth) / 5f
+    val buttonHeight = (calculatorHeight - separatorWidth * 2 - 3 * separatorWidth) / 4
+
     var yOffset = separatorWidth
+    val keys = if (keyboardMode == "NumWithCTA") numWithCTAKeys else defaultKeys
     for ((rowIndex, row) in keys.withIndex()) {
       var xOffset = separatorWidth
       for ((colIndex, key) in row.withIndex()) {
-        val isCustomKey = rowIndex == 2 && colIndex == 4
+        val isMainKey = rowIndex == 2 && colIndex == 4
+        val isMainCTAKey = isMainKey && keyboardMode == "NumWithCTA"
         val width = if (key == "000") buttonWidth * 2 + separatorWidth else buttonWidth
-        val height = if (isCustomKey) buttonHeight * 2 + separatorWidth else buttonHeight
+        val height = if (isMainKey) buttonHeight * 2 + separatorWidth else buttonHeight
 
         val button = if (key == "back") {
           createImageButton(key, xOffset, yOffset, buttonWidth.toInt(), buttonHeight.toInt())
         } else {
-          createButton(key, xOffset, yOffset, width.toInt(), height.toInt(), isCustomKey).also { b ->
-            if (isCustomKey) customKeyButton = b
+          createButton(key, xOffset, yOffset, width.toInt(), height.toInt(), isMainKey, isMainCTAKey).also { b ->
+            if (isMainCTAKey) customKeyButton = b
           }
         }
 
@@ -85,7 +91,8 @@ class CustomKeyboardView(
     yOffset: Float,
     buttonWidth: Int,
     buttonHeight: Int,
-    isCustomKey: Boolean
+    isMainKey: Boolean,
+    isMainCTAKey: Boolean
   ): Button {
     return Button(context).apply {
       val shapeInit = GradientDrawable().apply {
@@ -98,7 +105,7 @@ class CustomKeyboardView(
       background = shapeInit
       text = key
       setTypeface(typeface)
-      textSize = (if (isCustomKey) 18 else 24).toFloat()
+      textSize = (if (isMainCTAKey) 18 else 24).toFloat()
       setTextColor(Color.BLACK)
       stateListAnimator = null
       maxLines = 1
@@ -110,7 +117,7 @@ class CustomKeyboardView(
         constrainedWidth = false
       }
 
-      if (specialKeys.contains(key)) {
+      if (specialKeys.contains(key) || isMainKey) {
         background = GradientDrawable().apply {
           shape = GradientDrawable.RECTANGLE
           cornerRadius = 24f
@@ -125,7 +132,7 @@ class CustomKeyboardView(
 
       translationX = xOffset.toInt().toFloat()
       translationY = yOffset.toInt().toFloat()
-      setOnClickListener { onKeyPress(key, isCustomKey) }
+      setOnClickListener { onKeyPress(key, isMainCTAKey) }
     }
   }
 
@@ -163,46 +170,15 @@ class CustomKeyboardView(
     }
   }
 
-  fun updateButtonColors(color: Int) {
-    specialButtonColor = color
-    for (i in 0 until childCount) {
-      val child = getChildAt(i)
-      if (child is Button) {
-        val key = child.text.toString()
-        if (specialKeys.contains(key)) {
-          if (key == "=") {
-            child.background = GradientDrawable().apply {
-              shape = GradientDrawable.RECTANGLE
-              cornerRadius = 24f
-              setColor(specialButtonColor)
-            }
-          } else {
-            child.background = GradientDrawable().apply {
-              shape = GradientDrawable.RECTANGLE
-              cornerRadius = 24f
-              setColor(specialButtonColor)
-            }
-          }
-          child.setTextColor(Color.BLACK)
-        }
-      } else if (child is ImageButton) {
-        child.background = GradientDrawable().apply {
-          shape = GradientDrawable.RECTANGLE
-          cornerRadius = 24f
-          setColor(specialButtonColor)
-        }
-      }
-    }
-  }
-
-  private fun onKeyPress(key: String, isCustomKey: Boolean) {
-    if (isCustomKey) {
-      emitCustomKey()
+  private fun onKeyPress(key: String, isMainCTAKey: Boolean) {
+    if (isMainCTAKey) {
+      emitCustomKey(context)
       return
     }
 
-    emitKeyPress(key)
+    emitKeyPress(context, key)
     when (key) {
+      "AC" -> clearText()
       "back" -> onBackSpace()
       "=" -> calculateResult()
       "×", "+", "-", "÷" -> keyDidPress(" $key ")
@@ -215,6 +191,10 @@ class CustomKeyboardView(
     editText.text?.replace(editText.selectionStart, editText.selectionEnd, key)
   }
 
+  private fun clearText() {
+    editText.text?.clear()
+  }
+
   private fun onBackSpace() {
     val start = editText.selectionStart
     val end = editText.selectionEnd
@@ -251,44 +231,56 @@ class CustomKeyboardView(
     }
   }
 
-  private fun emitKeyPress(key: String) {
-    val reactContext = context as ThemedReactContext
-    val params = Arguments.createMap().apply {
-      putString("key", key)
-    }
-    reactContext.getJSModule(RCTEventEmitter::class.java)
-      .receiveEvent(editText.id, "onKeyPress", params)
+  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)
   }
 
-  private fun emitCustomKey() {
-    val reactContext = context as ThemedReactContext
-    reactContext.getJSModule(RCTEventEmitter::class.java)
-      .receiveEvent(editText.id, "onCustomKeyEvent", null)
+  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)
   }
 
   fun setCustomKeyText(text: String) {
     customKeyButton?.text = text
   }
 
+  fun setMode(mode: String) {
+    keyboardMode = mode
+    renderUI()
+  }
+
   fun setCustomKeyBackground(background: Int) {
     customKeyButtonBackground = background
-    updateCustomKeyUI(background, customKeyButtonTextColor, customKeyButtonState)
+    updateCustomKeyUI(background, customKeyButtonTextColor)
   }
 
   fun setCustomKeyTextColor(textColor: Int) {
     customKeyButtonTextColor = textColor
-    updateCustomKeyUI(customKeyButtonBackground, textColor, customKeyButtonState)
+    updateCustomKeyUI(customKeyButtonBackground, textColor)
   }
 
 
   fun setCustomKeyState(state: String) {
     customKeyButtonState = state
     customKeyButton?.isEnabled = state != "disable"
-    updateCustomKeyUI(customKeyButtonBackground, customKeyButtonTextColor, state)
+    updateCustomKeyUI(customKeyButtonBackground, customKeyButtonTextColor)
   }
 
-  private fun updateCustomKeyUI(background: Int, textColor: Int, state: String){
-
+  private fun updateCustomKeyUI(background: Int, textColor: Int){
     customKeyButton?.background = GradientDrawable().apply {
       shape = GradientDrawable.RECTANGLE
       cornerRadius = 24f
@@ -297,5 +289,4 @@ class CustomKeyboardView(
     customKeyButton?.setTextColor(textColor)
   }
 
-
 }

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

@@ -0,0 +1,36 @@
+package com.calculatorkeyboard
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val payload: WritableMap
+) : Event<OnChangeEvent>(surfaceId, viewId) {
+  override fun getEventName() = "onChange"
+
+  override fun getEventData() = payload
+}
+
+class OnKeyPressEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val payload: WritableMap
+) : Event<OnChangeEvent>(surfaceId, viewId) {
+  override fun getEventName() = "onKeyPress"
+
+  override fun getEventData() = payload
+}
+
+class OnCustomKeyPressEvent(
+  surfaceId: Int,
+  viewId: Int
+) : Event<OnChangeEvent>(surfaceId, viewId) {
+  override fun getEventName() = "onCustomKeyEvent"
+
+  override fun getEventData() = null
+}
+
+
+

package/android/src/main/java/com/calculatorkeyboard/{RCTInputCalculator.kt → InputCalculatorViewManager.kt}

@@ -3,20 +3,43 @@ package com.calculatorkeyboard
 import android.annotation.SuppressLint
 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
 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.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
 
-class RCTInputCalculator : ReactTextInputManager() {
+@ReactModule(name = InputCalculatorViewManager.REACT_CLASS)
+class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInputCalculatorManagerInterface<ReactEditText> {
+  private val delegate: NativeInputCalculatorManagerDelegate<ReactEditText, InputCalculatorViewManager> =
+    NativeInputCalculatorManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<ReactEditText> = delegate
+
+  override fun getName() = REACT_CLASS
 
   private var keyboardView: CustomKeyboardView? = null
   private lateinit var editText: CalculatorEditText
@@ -27,15 +50,14 @@ class RCTInputCalculator : ReactTextInputManager() {
   private var backListenerAttached = false
   private var overlayShowing = false
 
-  override fun getName() = REACT_CLASS
 
   companion object {
-    const val REACT_CLASS = "RCTInputCalculator"
+    const val REACT_CLASS = "NativeInputCalculator"
     val calculatorHeight: Int = 240.dpToPx().toInt()
   }
 
   @ReactProp(name = "value")
-  fun setValue(view: ReactEditText, value: String?) {
+  override fun setValue(view: ReactEditText, value: String?) {
     UiThreadUtil.runOnUiThread {
       val e = view.editableText ?: run { view.setText(value ?: ""); return@runOnUiThread }
       val newText = value ?: ""
@@ -48,29 +70,72 @@ class RCTInputCalculator : ReactTextInputManager() {
     }
   }
 
+  override fun setTextAttributes(view: ReactEditText?, value: ReadableMap?) {
+    val fontWeightStr = value?.getString("fontWeight")
+    val fontSize = value?.getDouble("fontSize")
+
+    fontWeightStr?.let { weightStr ->
+      val weight = when (weightStr) {
+        "100" -> 100
+        "200" -> 200
+        "300" -> 300
+        "400", "normal" -> 400
+        "500" -> 500
+        "600" -> 600
+        "700", "bold" -> 700
+        "800" -> 800
+        "900" -> 900
+        else -> 400
+      }
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        view?.typeface = Typeface.create(view.typeface, weight, false)
+      } else {
+        view?.typeface = if (weight >= 600) {
+          Typeface.create(view.typeface, Typeface.BOLD)
+        } else {
+          Typeface.create(view.typeface, Typeface.NORMAL)
+        }
+      }
+    }
+
+    fontSize?.let {
+      view?.textSize = it.toFloat()
+    }
+  }
+
+
+  @ReactProp(name = "mode")
+  override fun setMode(view: ReactEditText, mode: String?) {
+    keyboardView?.setMode(mode ?: "NumDefault")
+  }
+
   @ReactProp(name = "customKeyText")
-  fun setCustomKeyText(view: ReactEditText, text: String?) {
-    keyboardView?.setCustomKeyText(text ?: "Xong")
+  override fun setCustomKeyText(view: ReactEditText, text: String?) {
+    keyboardView?.setCustomKeyText(text ?: "Tiếp")
   }
 
   @ReactProp(name = "customKeyBackground")
-  fun setCustomKeyBackground(view: ReactEditText, background: String?) {
+  override fun setCustomKeyBackground(view: ReactEditText, background: String?) {
     keyboardView?.setCustomKeyBackground((background ?: "#d8d8d8").toColorInt())
   }
 
   @ReactProp(name = "customKeyTextColor")
-  fun setCustomKeyTextColor(view: ReactEditText, textColor: String?) {
+  override fun setCustomKeyTextColor(view: ReactEditText, textColor: String?) {
     keyboardView?.setCustomKeyTextColor(textColor?.toColorInt() ?: Color.BLACK)
   }
 
   @ReactProp(name = "customKeyState")
-  fun setCustomKeyState(view: ReactEditText, state: String?) {
+  override fun setCustomKeyState(view: ReactEditText, state: String?) {
     keyboardView?.setCustomKeyState(state ?: "default")
   }
 
-  @ReactProp(name = "keyboardColor")
-  fun setKeyboardColor(view: ReactEditText, color: String) {
-    keyboardView?.updateButtonColors(color.toColorInt())
+  override fun focus(view: ReactEditText?) {
+    UiThreadUtil.runOnUiThread { if (!editText.isFocused) editText.requestFocus() }
+  }
+
+  override fun blur(view: ReactEditText?) {
+    UiThreadUtil.runOnUiThread { if (editText.isFocused) editText.clearFocus() }
   }
 
   @SuppressLint("ClickableViewAccessibility")
@@ -101,6 +166,16 @@ class RCTInputCalculator : ReactTextInputManager() {
         }
         false
       }
+      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) {}
+
+        override fun afterTextChanged(s: Editable?) {
+          emitOnChange(context, s.toString())
+        }
+
+      })
     }
 
     keyboardView = CustomKeyboardView(context, editText).apply {
@@ -165,33 +240,31 @@ class RCTInputCalculator : ReactTextInputManager() {
     v.showSoftInputOnFocus = true
   }
 
-  override fun getCommandsMap(): Map<String, Int> = mapOf("blur" to 1, "focus" to 2)
+  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)
 
-  override fun receiveCommand(reactEditText: ReactEditText, commandId: Int, args: ReadableArray?) {
-    when (commandId) {
-      1 -> blur()
-      2 -> focus()
-    }
+    eventDispatcher?.dispatchEvent(event)
   }
 
   override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
-    val base = super.getExportedCustomBubblingEventTypeConstants().toMutableMap()
+    val base = super.getExportedCustomBubblingEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
     base["onKeyPress"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onKeyPress"))
+    base["onChange"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onChange"))
     return base
   }
 
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
-    val base = super.getExportedCustomDirectEventTypeConstants().toMutableMap()
+    val base = super.getExportedCustomDirectEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
     base["onCustomKeyEvent"] = mapOf("registrationName" to "onCustomKeyEvent")
     return base
   }
 
-  private fun focus() {
-    UiThreadUtil.runOnUiThread { if (!editText.isFocused) editText.requestFocus() }
-  }
-
-  private fun blur() {
-    UiThreadUtil.runOnUiThread { if (editText.isFocused) editText.clearFocus() }
-  }
 }
 

package/ios/CalculatorKeyboardView.h

@@ -0,0 +1,30 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol CalculatorKeyboardInput <NSObject>
+
+- (void)keyDidPress:(NSString *)key;
+- (void)clearText;
+- (void)onBackSpace;
+- (void)calculateResult;
+- (void)emitCustomKey;
+- (void)emitKeyPress:(NSString *)key;
+
+@end
+
+@interface CalculatorKeyboardView : UIView
+
+@property (nonatomic, weak, nullable) id<CalculatorKeyboardInput> input;
+@property (nonatomic, strong, nullable) NSString *keyboardMode;
+@property (nonatomic, strong, nullable) NSString *customKeyText;
+@property (nonatomic, strong, nullable) NSString *customKeyBackground;
+@property (nonatomic, strong, nullable) NSString *customKeyTextColor;
+@property (nonatomic, strong, nullable) NSString *customKeyState;
+
+- (void)setKeyboardColor:(UIColor *)color;
+
+@end
+
+NS_ASSUME_NONNULL_END
+