@momo-kits/calculator-keyboard 0.150.2-phuc.15 → 0.151.1-beta.2

package/ios/NativeInputCalculator.mm

@@ -0,0 +1,500 @@
+#import "NativeInputCalculator.h"
+#import "CalculatorKeyboardView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <react/renderer/components/CalculatorKeyboardSpecs/ComponentDescriptors.h>
+#import <react/renderer/components/CalculatorKeyboardSpecs/EventEmitters.h>
+#import <react/renderer/components/CalculatorKeyboardSpecs/Props.h>
+#import <react/renderer/components/CalculatorKeyboardSpecs/RCTComponentViewHelpers.h>
+
+#import "Utils.h"
+
+using namespace facebook::react;
+
+@interface NativeInputCalculator () <RCTNativeInputCalculatorViewProtocol>
+@end
+
+@implementation NativeInputCalculator {
+  UITextField *_textField;
+  CalculatorKeyboardView *_keyboardView;
+  NSString *_lastValue;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const NativeInputCalculatorProps>();
+    _props = defaultProps;
+
+    // Create text field
+    _textField = [[UITextField alloc] initWithFrame:self.bounds];
+    _textField.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    _textField.delegate = (id<UITextFieldDelegate>)self;
+
+    // Create keyboard view
+    CGFloat bottomInset = [self getBottomInset];
+    CGRect keyboardFrame = CGRectMake(0, 0, UIScreen.mainScreen.bounds.size.width, 240 + bottomInset);
+    _keyboardView = [[CalculatorKeyboardView alloc] initWithFrame:keyboardFrame];
+    _keyboardView.input = (id)self; // Bridge pattern
+
+    // 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;
+  CGFloat bottom = window.safeAreaInsets.bottom > 0 ? 21 : 0;
+  return bottom;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<NativeInputCalculatorComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<const NativeInputCalculatorProps>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<const NativeInputCalculatorProps>(props);
+
+  if (oldViewProps.value != newViewProps.value) {
+    NSString *newValue = RCTNSStringFromString(newViewProps.value);
+    if (![_lastValue isEqualToString:newValue]) {
+      _textField.text = newValue;
+      _lastValue = newValue;
+      [self reformatAndKeepSelection];
+      [self notifyTextChange];
+    }
+  }
+
+  if (oldViewProps.mode != newViewProps.mode) {
+    _keyboardView.keyboardMode = RCTNSStringFromString(newViewProps.mode);
+  }
+
+  if (oldViewProps.customKeyText != newViewProps.customKeyText) {
+    _keyboardView.customKeyText = RCTNSStringFromString(newViewProps.customKeyText);
+  }
+
+  if (oldViewProps.customKeyBackground != newViewProps.customKeyBackground) {
+    _keyboardView.customKeyBackground = RCTNSStringFromString(newViewProps.customKeyBackground);
+  }
+
+  if (oldViewProps.customKeyTextColor != newViewProps.customKeyTextColor) {
+    _keyboardView.customKeyTextColor = RCTNSStringFromString(newViewProps.customKeyTextColor);
+  }
+
+  if (oldViewProps.customKeyState != newViewProps.customKeyState) {
+    _keyboardView.customKeyState = RCTNSStringFromString(newViewProps.customKeyState);
+  }
+
+  if (oldViewProps.textAttributes.fontSize != newViewProps.textAttributes.fontSize > 0.0f) {
+    CGFloat newSize = (CGFloat)newViewProps.textAttributes.fontSize;
+      UIFont *current = _textField.font ?: [UIFont systemFontOfSize:UIFont.systemFontSize];
+      _textField.font = [current fontWithSize:newSize];
+  }
+
+  if (oldViewProps.textAttributes.fontWeight != newViewProps.textAttributes.fontWeight) {
+    UIFontWeight weight = _UIFontWeightFromString(newViewProps.textAttributes.fontWeight);
+      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];
+}
+
+static UIFontWeight _UIFontWeightFromString(std::string_view s) {
+  std::string v(s);
+  for (auto &c : v) c = (char)tolower((unsigned char)c);
+
+  if (v == "normal" || v == "400") return UIFontWeightRegular;
+  if (v == "bold"   || v == "700") return UIFontWeightBold;
+  if (v == "100") return UIFontWeightUltraLight;
+  if (v == "200") return UIFontWeightThin;
+  if (v == "300") return UIFontWeightLight;
+  if (v == "500") return UIFontWeightMedium;
+  if (v == "600") return UIFontWeightSemibold;
+  if (v == "800") return UIFontWeightHeavy;
+  if (v == "900") return UIFontWeightBlack;
+  return UIFontWeightRegular;
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTNativeInputCalculatorHandleCommand(self, commandName, args);
+}
+
+#pragma mark - RCTNativeInputCalculatorViewProtocol
+
+- (void)focus
+{
+  [_textField becomeFirstResponder];
+}
+
+- (void)blur
+{
+  [_textField resignFirstResponder];
+}
+
+#pragma mark - Keyboard callbacks (called by CalculatorKeyboardView)
+
+- (void)keyDidPress:(NSString *)key {
+  UITextRange *sel = _textField.selectedTextRange;
+  if (!sel) return;
+
+  NSArray<NSString *> *ops = @[ @" + ", @" - ", @" × ", @" ÷ " ];
+  BOOL isOperatorKey = [ops containsObject:key];
+
+  if (!sel.isEmpty) {
+    [_textField replaceRange:sel withText:key];
+  } else {
+    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];
+}
+
+- (void)clearText
+{
+  _textField.text = @"";
+  [self notifyTextChange];
+}
+
+- (NSString *)getText
+{
+  return _textField.text;
+}
+
+- (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;
+
+  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];
+  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:delStart inFormatted:formattedAfter];
+  UITextPosition *pos = [_textField positionFromPosition:_textField.beginningOfDocument offset:newCaretFmt];
+  if (pos) {
+    _textField.selectedTextRange = [_textField textRangeFromPosition:pos toPosition:pos];
+  }
+
+  [self notifyTextChange];
+}
+
+- (NSString *)calculate {
+  NSString *text = _textField.text ?: @"";
+  NSString *invalid = @"invalid";
+
+  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];
+  if (![regex firstMatchInString:text options:0 range:NSMakeRange(0, text.length)]) {
+    NSLog(@"Invalid expression");
+    return invalid;
+  }
+
+  @try {
+    NSExpression *expr = [NSExpression expressionWithFormat:text];
+    id val = [expr expressionValueWithObject:nil context:nil];
+    if ([val isKindOfClass:[NSNumber class]]) {
+      return [(NSNumber *)val stringValue];
+    }
+  } @catch (__unused NSException *e) { return invalid; }
+  return invalid;
+}
+
+- (void)calculateResult {
+  NSString *result = [self calculate];
+  if ([result isEqual: @"invalid"]) return;
+  NSString *formatted = [self formatNumberGroups:result];
+  _textField.text = formatted;
+
+  UITextPosition *end = _textField.endOfDocument;
+  _textField.selectedTextRange = [_textField textRangeFromPosition:end toPosition:end];
+
+  [self notifyTextChange];
+}
+
+- (void)emitCustomKey
+{
+  if (_eventEmitter) {
+    auto emitter = std::static_pointer_cast<const NativeInputCalculatorEventEmitter>(_eventEmitter);
+    NativeInputCalculatorEventEmitter::OnCustomKeyEvent event{};
+    emitter->onCustomKeyEvent(event);
+  }
+}
+
+- (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) {
+    auto emitter = std::static_pointer_cast<const NativeInputCalculatorEventEmitter>(_eventEmitter);
+    NativeInputCalculatorEventEmitter::OnKeyPress event{
+      .key = std::string([key UTF8String])
+    };
+    emitter->onKeyPress(event);
+  }
+}
+
+- (void)notifyTextChange
+{
+  _lastValue = _textField.text;
+
+  if (_eventEmitter) {
+    auto emitter = std::static_pointer_cast<const NativeInputCalculatorEventEmitter>(_eventEmitter);
+    NativeInputCalculatorEventEmitter::OnChange event{
+      .text = std::string([_textField.text UTF8String])
+    };
+    emitter->onChange(event);
+
+    NSString *result = [self calculate];
+    NativeInputCalculatorEventEmitter::OnResult event1{
+      .result = std::string([result UTF8String])
+    };
+    emitter->onResult(event1);
+
+  }
+}
+
+#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)
+{
+  return NativeInputCalculator.class;
+}
+

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