@momo-kits/calculator-keyboard 0.150.2-phuc.13 → 0.151.1-beta.1

package/ios/CalculatorKeyboardView.mm

@@ -0,0 +1,231 @@
+#import "CalculatorKeyboardView.h"
+
+@interface CalculatorKeyboardView ()
+@property (nonatomic, strong) NSArray<NSArray<NSString *> *> *numWithCTAKeys;
+@property (nonatomic, strong) NSArray<NSArray<NSString *> *> *defaultKeys;
+@property (nonatomic, strong) NSSet<NSString *> *specialKeys;
+@property (nonatomic, weak) UIButton *customKeyButton;
+@end
+
+@implementation CalculatorKeyboardView {
+  CGFloat _separatorWidth;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _separatorWidth = 4.0;
+    
+    _numWithCTAKeys = @[
+      @[@"1", @"2", @"3", @"÷", @"back"],
+      @[@"4", @"5", @"6", @"×", @"="],
+      @[@"7", @"8", @"9", @"-", @"Tiếp"],
+      @[@"000", @"0", @"+"]
+    ];
+    
+    _defaultKeys = @[
+      @[@"1", @"2", @"3", @"÷", @"AC"],
+      @[@"4", @"5", @"6", @"×", @"back"],
+      @[@"7", @"8", @"9", @"-", @"="],
+      @[@"000", @"0", @"+"]
+    ];
+    
+    _specialKeys = [NSSet setWithArray:@[@"=", @"-", @"×", @"÷", @"back", @"+", @"AC"]];
+    
+    [self setup];
+  }
+  return self;
+}
+
+- (void)setKeyboardMode:(NSString *)keyboardMode
+{
+  if ([_keyboardMode isEqualToString:keyboardMode]) {
+    return;
+  }
+  _keyboardMode = keyboardMode;
+  [self setup];
+}
+
+- (void)setCustomKeyText:(NSString *)customKeyText
+{
+  _customKeyText = customKeyText;
+  [self updateCustomKeyTitle];
+}
+
+- (void)setCustomKeyBackground:(NSString *)customKeyBackground
+{
+  _customKeyBackground = customKeyBackground;
+  [self updateCustomKeyBackground];
+}
+
+- (void)setCustomKeyTextColor:(NSString *)customKeyTextColor
+{
+  _customKeyTextColor = customKeyTextColor;
+  [self updateCustomKeyBackground];
+}
+
+- (void)setCustomKeyState:(NSString *)customKeyState
+{
+  _customKeyState = customKeyState;
+  [self updateCustomKeyBackground];
+}
+
+- (void)setKeyboardColor:(UIColor *)color
+{
+  [self setup];
+}
+
+- (void)setup
+{
+  // Remove all subviews
+  for (UIView *subview in self.subviews) {
+    [subview removeFromSuperview];
+  }
+  
+  self.backgroundColor = [self colorFromHex:@"#f2f2f6"];
+  
+  CGFloat buttonWidth = (UIScreen.mainScreen.bounds.size.width - _separatorWidth * 2 - 4 * _separatorWidth) / 5;
+  CGFloat buttonHeight = (240 - _separatorWidth * 2 - 3 * _separatorWidth) / 4;
+  
+  // Create content view
+  UIView *contentView = [[UIView alloc] init];
+  contentView.translatesAutoresizingMaskIntoConstraints = NO;
+  [self addSubview:contentView];
+  
+  // Set contentView constraints
+  [NSLayoutConstraint activateConstraints:@[
+    [contentView.leadingAnchor constraintEqualToAnchor:self.leadingAnchor constant:_separatorWidth],
+    [contentView.trailingAnchor constraintEqualToAnchor:self.trailingAnchor constant:-_separatorWidth],
+    [contentView.topAnchor constraintEqualToAnchor:self.topAnchor constant:_separatorWidth],
+    [contentView.bottomAnchor constraintEqualToAnchor:self.bottomAnchor constant:-_separatorWidth]
+  ]];
+  
+  CGFloat yOffset = 0;
+  NSArray<NSArray<NSString *> *> *keys = [_keyboardMode isEqualToString:@"NumDefault"] ? _defaultKeys : _numWithCTAKeys;
+  
+  for (NSInteger rowIndex = 0; rowIndex < keys.count; rowIndex++) {
+    NSArray<NSString *> *row = keys[rowIndex];
+    CGFloat xOffset = 0;
+    
+    for (NSInteger colIndex = 0; colIndex < row.count; colIndex++) {
+      NSString *key = row[colIndex];
+      BOOL isMainKey = (colIndex == 4 && rowIndex == 2);
+      BOOL isMainCTAKey = isMainKey && [_keyboardMode isEqualToString:@"NumWithCTA"];
+      
+      UIButton *button = [UIButton buttonWithType:UIButtonTypeSystem];
+      button.backgroundColor = UIColor.whiteColor;
+      button.layer.cornerRadius = 8;
+      
+      NSString *title = isMainCTAKey ? (_customKeyText ?: key) : key;
+      [button setTitle:title forState:UIControlStateNormal];
+      [button setTitleColor:UIColor.blackColor forState:UIControlStateNormal];
+      button.titleLabel.font = [UIFont systemFontOfSize:isMainCTAKey ? 18 : 24 weight:UIFontWeightMedium];
+      button.accessibilityIdentifier = key;
+      button.tag = isMainCTAKey ? 1 : 0;
+      
+      CGRect buttonFrame = CGRectMake(xOffset, yOffset, buttonWidth, buttonHeight);
+      if (isMainKey) {
+        buttonFrame.size.height = buttonHeight * 2 + _separatorWidth;
+      }
+      if ([key isEqualToString:@"000"]) {
+        buttonFrame.size.width = buttonWidth * 2 + _separatorWidth;
+      }
+      
+      button.frame = buttonFrame;
+      
+      if ([key isEqualToString:@"back"]) {
+        [button setTitle:@"" forState:UIControlStateNormal];
+        UIImageSymbolConfiguration *config = [UIImageSymbolConfiguration configurationWithWeight:UIImageSymbolWeightBold];
+        UIImage *image = [UIImage systemImageNamed:@"delete.backward" withConfiguration:config];
+        [button setImage:image forState:UIControlStateNormal];
+        button.tintColor = UIColor.blackColor;
+      }
+      
+      if ([_specialKeys containsObject:key] || isMainKey) {
+        [button setTitleColor:UIColor.blackColor forState:UIControlStateNormal];
+        button.backgroundColor = [self colorFromHex:@"#d8d8d8"];
+      }
+      
+      if (isMainKey) {
+        self.customKeyButton = button;
+      }
+      
+      [button addTarget:self action:@selector(keyPressed:) forControlEvents:UIControlEventTouchUpInside];
+      [contentView addSubview:button];
+      
+      xOffset += buttonFrame.size.width + _separatorWidth;
+    }
+    
+    yOffset += buttonHeight + _separatorWidth;
+  }
+}
+
+- (void)updateCustomKeyTitle
+{
+  if (!self.customKeyButton || !_customKeyText) {
+    return;
+  }
+  [self.customKeyButton setTitle:_customKeyText forState:UIControlStateNormal];
+  [self.customKeyButton setImage:nil forState:UIControlStateNormal];
+}
+
+- (void)updateCustomKeyBackground
+{
+  if (!self.customKeyButton || !_keyboardMode || !_customKeyBackground || !_customKeyTextColor || !_customKeyState) {
+    return;
+  }
+  
+  if ([_keyboardMode isEqualToString:@"numWithCTA"]) {
+    self.customKeyButton.enabled = ![_customKeyState isEqualToString:@"disable"];
+  } else {
+    self.customKeyButton.enabled = YES;
+  }
+  
+  self.customKeyButton.backgroundColor = [self colorFromHex:_customKeyBackground];
+  [self.customKeyButton setTitleColor:[self colorFromHex:_customKeyTextColor] forState:UIControlStateNormal];
+}
+
+- (void)keyPressed:(UIButton *)sender
+{
+  NSString *key = sender.accessibilityIdentifier;
+  if (!key) {
+    return;
+  }
+  
+  BOOL isCustomKeyCTA = (sender.tag == 1);
+  if (isCustomKeyCTA) {
+    [self.input emitCustomKey];
+    return;
+  }
+  
+  [self.input emitKeyPress:key];
+  
+  if ([key isEqualToString:@"AC"]) {
+    [self.input clearText];
+  } else if ([key isEqualToString:@"back"]) {
+    [self.input onBackSpace];
+  } else if ([key isEqualToString:@"="]) {
+    [self.input calculateResult];
+  } else if ([key isEqualToString:@"+"] || [key isEqualToString:@"-"] || 
+             [key isEqualToString:@"÷"] || [key isEqualToString:@"×"]) {
+    [self.input keyDidPress:[NSString stringWithFormat:@" %@ ", key]];
+  } else {
+    [self.input keyDidPress: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.h

@@ -0,0 +1,11 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NativeInputCalculator : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+

package/ios/NativeInputCalculator.mm

@@ -0,0 +1,369 @@
+#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>
+
+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 addSubview:_textField];
+  }
+  return 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;
+    }
+  }
+
+  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];
+  }
+
+  [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) {
+    [_textField replaceRange:sel withText:key];
+  } else {
+    [_textField insertText:key];
+  }
+  [self reformatAndKeepSelection];
+  [self notifyTextChange];
+}
+
+- (void)clearText
+{
+  _textField.text = @"";
+  [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 ?: @"";
+
+  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;
+  }
+
+  @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];
+
+      [self notifyTextChange];
+    }
+  } @catch (__unused NSException *e) {  }
+}
+
+- (void)emitCustomKey
+{
+  if (_eventEmitter) {
+    auto emitter = std::static_pointer_cast<const NativeInputCalculatorEventEmitter>(_eventEmitter);
+    NativeInputCalculatorEventEmitter::OnCustomKeyEvent event{};
+    emitter->onCustomKeyEvent(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);
+  }
+}
+
+#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;
+}
+