@momo-kits/calculator-keyboard 0.150.2-beta.28 → 0.150.2-beta.30

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

@@ -184,6 +184,8 @@ class CustomKeyboardView(
       "×", "+", "-", "÷" -> keyDidPress(" $key ")
       else -> editText.text?.insert(editText.selectionStart, key)
     }
+
+    reformatAndKeepSelection(editText)
   }
 
   private fun keyDidPress(key: String) {
@@ -196,26 +198,39 @@ class CustomKeyboardView(
   }
 
   private fun onBackSpace() {
-    val start = editText.selectionStart
-    val end = editText.selectionEnd
-    if (start > 0) {
-      val newText = end.let { editText.text?.replaceRange(start - 1, it, "") }
-      editText.setText(newText)
-      editText.setSelection(start - 1)
+    val formatted = editText.text?.toString().orEmpty()
+    val caretFmt  = editText.selectionStart.coerceAtLeast(0)
+
+    val rawBefore = stripGroupDots(formatted)
+    val caretRaw  = formattedCaretToRaw(formatted, caretFmt)
+
+    if (caretRaw <= 0) return
+
+    val rawAfter = buildString(rawBefore.length - 1) {
+      append(rawBefore, 0, caretRaw - 1)
+      append(rawBefore, caretRaw, rawBefore.length)
     }
+
+    val formattedAfter = formatNumberGroups(rawAfter)
+    editText.setText(formattedAfter)
+    val newCaretFmt = rawCaretToFormatted(caretRaw - 1, formattedAfter)
+    editText.setSelection(newCaretFmt.coerceIn(0, formattedAfter.length))
   }
 
+
   private fun calculateResult() {
-    val text = editText?.text.toString().replace("×", "*").replace("÷", "/")
+    val raw = editText.text?.toString().orEmpty()
+    val normalized = raw.replace(".", "")
+      .replace("×", "*")
+      .replace("÷", "/")
+
     val pattern = "^\\s*(-?\\d+(\\.\\d+)?\\s*[-+*/]\\s*)*-?\\d+(\\.\\d+)?\\s*$"
-    val regex = Regex(pattern)
-    if (regex.matches(text)) {
+    if (Regex(pattern).matches(normalized)) {
       try {
-        val result = eval(text).toString()
-        editText.setTextKeepState(result)
-      } catch (e: Exception) {
-        e.printStackTrace()
-      }
+        val result = eval(normalized)?.toString() ?: return
+        editText.setTextKeepState(formatNumberGroups(result))
+        editText.setSelection(editText.text?.length ?: 0)
+      } catch (_: Exception) { /* ignore */ }
     } else {
       println("Invalid expression")
     }
@@ -289,4 +304,74 @@ class CustomKeyboardView(
     customKeyButton?.setTextColor(textColor)
   }
 
+  private fun reformatAndKeepSelection(editText: CalculatorEditText) {
+    val formattedBefore = editText.text?.toString() ?: return
+    val caretFmtBefore = editText.selectionStart.coerceAtLeast(0)
+
+    val caretRaw = formattedCaretToRaw(formattedBefore, caretFmtBefore)
+
+    val formattedAfter = formatNumberGroups(formattedBefore)
+
+    if (formattedAfter != formattedBefore) {
+      editText.setText(formattedAfter)
+    }
+
+    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
+    var i = 0
+    while (i < caretFmt && i < formatted.length) {
+      val c = formatted[i]
+      if (!(c == '.' && isGroupDotAt(formatted, i))) {
+        rawIdx++
+      }
+      i++
+    }
+    return rawIdx
+  }
+
+  private fun rawCaretToFormatted(rawCaret: Int, formatted: String): Int {
+    var rawSeen = 0
+    var i = 0
+    while (i < formatted.length) {
+      val c = formatted[i]
+      if (!(c == '.' && isGroupDotAt(formatted, i))) {
+        if (rawSeen == rawCaret) return i
+        rawSeen++
+      }
+      i++
+    }
+    return formatted.length
+  }
 }

package/ios/NativeInputCalculator.mm

@@ -63,7 +63,6 @@ using namespace facebook::react;
   const auto &oldViewProps = *std::static_pointer_cast<const NativeInputCalculatorProps>(_props);
   const auto &newViewProps = *std::static_pointer_cast<const NativeInputCalculatorProps>(props);
 
-  // Update value
   if (oldViewProps.value != newViewProps.value) {
     NSString *newValue = RCTNSStringFromString(newViewProps.value);
     if (![_lastValue isEqualToString:newValue]) {
@@ -72,33 +71,26 @@ using namespace facebook::react;
     }
   }
 
-  // Update mode
   if (oldViewProps.mode != newViewProps.mode) {
     _keyboardView.keyboardMode = RCTNSStringFromString(newViewProps.mode);
   }
 
-  // Update customKeyText
   if (oldViewProps.customKeyText != newViewProps.customKeyText) {
     _keyboardView.customKeyText = RCTNSStringFromString(newViewProps.customKeyText);
   }
 
-  // Update customKeyBackground
   if (oldViewProps.customKeyBackground != newViewProps.customKeyBackground) {
     _keyboardView.customKeyBackground = RCTNSStringFromString(newViewProps.customKeyBackground);
   }
 
-  // Update customKeyTextColor
   if (oldViewProps.customKeyTextColor != newViewProps.customKeyTextColor) {
     _keyboardView.customKeyTextColor = RCTNSStringFromString(newViewProps.customKeyTextColor);
   }
 
-  // Update customKeyState
   if (oldViewProps.customKeyState != newViewProps.customKeyState) {
     _keyboardView.customKeyState = RCTNSStringFromString(newViewProps.customKeyState);
   }
 
-  // ===== textAttributes (fontSize, fontWeight) =====
-  // Codegen should have a prop like: std::optional<folly::dynamic> textAttributes;
   if (oldViewProps.textAttributes.fontSize != newViewProps.textAttributes.fontSize > 0.0f) {
     CGFloat newSize = (CGFloat)newViewProps.textAttributes.fontSize;
       UIFont *current = _textField.font ?: [UIFont systemFontOfSize:UIFont.systemFontSize];
@@ -149,9 +141,14 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
 
 #pragma mark - Keyboard callbacks (called by CalculatorKeyboardView)
 
-- (void)keyDidPress:(NSString *)key
-{
-  [_textField insertText:key];
+- (void)keyDidPress:(NSString *)key {
+  UITextRange *sel = _textField.selectedTextRange;
+  if (sel) {
+    [_textField replaceRange:sel withText:key];
+  } else {
+    [_textField insertText:key];
+  }
+  [self reformatAndKeepSelection];
   [self notifyTextChange];
 }
 
@@ -161,31 +158,61 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   [self notifyTextChange];
 }
 
-- (void)onBackSpace
-{
-  if (_textField.text.length > 0) {
-    _textField.text = [_textField.text substringToIndex:_textField.text.length - 1];
-    [self notifyTextChange];
+- (void)onBackSpace {
+  NSString *formatted = _textField.text ?: @"";
+  if (formatted.length == 0) return;
+
+  UITextRange *selRange = _textField.selectedTextRange;
+  NSInteger caretFmt = (NSInteger)[_textField offsetFromPosition:_textField.beginningOfDocument
+                                                     toPosition:selRange.start];
+
+  NSString *rawBefore = [self stripGroupDots:formatted];
+  NSInteger caretRaw = [self formattedCaretToRaw:formatted caret:caretFmt];
+  if (caretRaw <= 0) return;
+
+  NSMutableString *rawAfter = [rawBefore mutableCopy];
+  [rawAfter deleteCharactersInRange:NSMakeRange(caretRaw - 1, 1)];
+
+  NSString *formattedAfter = [self formatNumberGroups:rawAfter];
+  _textField.text = formattedAfter;
+
+  NSInteger newCaretFmt = [self rawCaretToFormatted:(caretRaw - 1) inFormatted:formattedAfter];
+  UITextPosition *pos = [_textField positionFromPosition:_textField.beginningOfDocument offset:newCaretFmt];
+  if (pos) {
+    _textField.selectedTextRange = [_textField textRangeFromPosition:pos toPosition:pos];
   }
+
+  [self notifyTextChange];
 }
 
-- (void)calculateResult
-{
-  NSString *text = [_textField.text stringByReplacingOccurrencesOfString:@"×" withString:@"*"];
+- (void)calculateResult {
+  NSString *text = _textField.text ?: @"";
+
+  text = [self stripGroupDots:text];
+  text = [text stringByReplacingOccurrencesOfString:@"×" withString:@"*"];
   text = [text stringByReplacingOccurrencesOfString:@"÷" withString:@"/"];
 
   NSString *pattern = @"^\\s*(-?\\d+(\\.\\d+)?\\s*[-+*/]\\s*)*-?\\d+(\\.\\d+)?\\s*$";
   NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:nil];
-  NSRange range = NSMakeRange(0, text.length);
+  if (![regex firstMatchInString:text options:0 range:NSMakeRange(0, text.length)]) {
+    NSLog(@"Invalid expression");
+    return;
+  }
+
+  @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;
+
+      UITextPosition *end = _textField.endOfDocument;
+      _textField.selectedTextRange = [_textField textRangeFromPosition:end toPosition:end];
 
-  if ([regex firstMatchInString:text options:0 range:range]) {
-    NSExpression *expression = [NSExpression expressionWithFormat:text];
-    id result = [expression expressionValueWithObject:nil context:nil];
-    if ([result isKindOfClass:[NSNumber class]]) {
-      _textField.text = [result stringValue];
       [self notifyTextChange];
     }
-  }
+  } @catch (__unused NSException *e) {  }
 }
 
 - (void)emitCustomKey
@@ -221,6 +248,118 @@ static UIFontWeight _UIFontWeightFromString(std::string_view s) {
   }
 }
 
+#pragma mark - Thousand grouping helpers (strip/format + caret mapping)
+
+- (BOOL)isGroupDotAt:(NSInteger)i inString:(NSString *)s {
+  if (i < 0 || i >= (NSInteger)s.length) return NO;
+  unichar c = [s characterAtIndex:i];
+  if (c != '.') return NO;
+  BOOL leftIsDigit  = (i - 1 >= 0) && [[NSCharacterSet decimalDigitCharacterSet] characterIsMember:[s characterAtIndex:i-1]];
+  BOOL rightIsDigit = (i + 1 < (NSInteger)s.length) && [[NSCharacterSet decimalDigitCharacterSet] characterIsMember:[s characterAtIndex:i+1]];
+  return leftIsDigit && rightIsDigit;
+}
+
+- (NSString *)stripGroupDots:(NSString *)input {
+  if (input.length == 0) return input;
+  NSMutableString *out = [NSMutableString stringWithCapacity:input.length];
+  for (NSInteger i = 0; i < (NSInteger)input.length; i++) {
+    unichar c = [input characterAtIndex:i];
+    if (c == '.' && [self isGroupDotAt:i inString:input]) {
+      // skip
+    } else {
+      [out appendFormat:@"%C", c];
+    }
+  }
+  return out;
+}
+
+- (NSString *)formatNumberGroups:(NSString *)input {
+  NSString *noSep = [self stripGroupDots:input];
+  if (noSep.length == 0) return noSep;
+
+  NSError *err = nil;
+  NSRegularExpression *re = [NSRegularExpression regularExpressionWithPattern:@"\\d+" options:0 error:&err];
+  if (err) return noSep;
+
+  NSMutableString *result = [noSep mutableCopy];
+  __block NSInteger delta = 0;
+  [re enumerateMatchesInString:noSep options:0 range:NSMakeRange(0, noSep.length) usingBlock:^(NSTextCheckingResult * _Nullable match, NSMatchingFlags flags, BOOL * _Nonnull stop) {
+    if (!match) return;
+    NSRange mr = match.range;
+    mr.location += delta;
+
+    NSString *digits = [result substringWithRange:mr];
+
+    NSMutableString *rev = [NSMutableString stringWithCapacity:digits.length];
+    for (NSInteger i = digits.length - 1; i >= 0; i--) {
+      [rev appendFormat:@"%C", [digits characterAtIndex:i]];
+    }
+
+    NSMutableArray<NSString *> *chunks = [NSMutableArray array];
+    for (NSInteger i = 0; i < (NSInteger)rev.length; i += 3) {
+      NSRange r = NSMakeRange(i, MIN(3, (NSInteger)rev.length - i));
+      [chunks addObject:[rev substringWithRange:r]];
+    }
+    NSString *joined = [chunks componentsJoinedByString:@"."];
+
+    NSMutableString *final = [NSMutableString stringWithCapacity:joined.length];
+    for (NSInteger i = joined.length - 1; i >= 0; i--) {
+      [final appendFormat:@"%C", [joined characterAtIndex:i]];
+    }
+
+    [result replaceCharactersInRange:mr withString:final];
+    delta += (final.length - mr.length);
+  }];
+
+  return result;
+}
+
+- (NSInteger)formattedCaretToRaw:(NSString *)formatted caret:(NSInteger)caretFmt {
+  NSInteger rawIdx = 0;
+  NSInteger limit = MIN(caretFmt, (NSInteger)formatted.length);
+  for (NSInteger i = 0; i < limit; i++) {
+    unichar c = [formatted characterAtIndex:i];
+    if (!(c == '.' && [self isGroupDotAt:i inString:formatted])) {
+      rawIdx++;
+    }
+  }
+  return rawIdx;
+}
+
+- (NSInteger)rawCaretToFormatted:(NSInteger)rawCaret inFormatted:(NSString *)formatted {
+  NSInteger rawSeen = 0;
+  for (NSInteger i = 0; i < (NSInteger)formatted.length; i++) {
+    unichar c = [formatted characterAtIndex:i];
+    if (!(c == '.' && [self isGroupDotAt:i inString:formatted])) {
+      if (rawSeen == rawCaret) return i;
+      rawSeen++;
+    }
+  }
+  return (NSInteger)formatted.length;
+}
+
+- (void)reformatAndKeepSelection {
+  NSString *formattedBefore = _textField.text ?: @"";
+
+  UITextRange *selRange = _textField.selectedTextRange;
+  NSInteger caretFmtBefore = (NSInteger)[_textField offsetFromPosition:_textField.beginningOfDocument
+                                                            toPosition:selRange.start];
+
+  NSInteger caretRaw = [self formattedCaretToRaw:formattedBefore caret:caretFmtBefore];
+  NSString *formattedAfter = [self formatNumberGroups:formattedBefore];
+
+  if (![formattedAfter isEqualToString:formattedBefore]) {
+    _textField.text = formattedAfter;
+  }
+
+  NSInteger caretFmtAfter = [self rawCaretToFormatted:caretRaw inFormatted:formattedAfter];
+  UITextPosition *pos = [_textField positionFromPosition:_textField.beginningOfDocument offset:caretFmtAfter];
+  if (pos) {
+    _textField.selectedTextRange = [_textField textRangeFromPosition:pos toPosition:pos];
+  }
+}
+
+
 @end
 
 Class<RCTNativeInputCalculatorViewProtocol> NativeInputCalculatorCls(void)

package/package.json

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