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

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;
+}
+

package/package.json

@@ -1,22 +1,8 @@
 {
     "name": "@momo-kits/calculator-keyboard",
-    "version": "0.150.2-phuc.15",
+    "version": "0.151.1-beta.1",
     "description": "react native calculator keyboard",
-    "source": "./src/index.tsx",
-    "main": "./lib/commonjs/index.js",
-    "module": "./lib/module/index.js",
-    "exports": {
-        ".": {
-            "import": {
-                "types": "./lib/typescript/module/src/index.d.ts",
-                "default": "./lib/module/index.js"
-            },
-            "require": {
-                "types": "./lib/typescript/commonjs/src/index.d.ts",
-                "default": "./lib/commonjs/index.js"
-            }
-        }
-    },
+    "main": "./src/index.tsx",
     "files": [
         "src",
         "lib",
@@ -40,9 +26,7 @@
         "test": "jest",
         "typecheck": "tsc",
         "lint": "eslint \"**/*.{js,ts,tsx}\"",
-        "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
-        "build": "bob build",
-        "release": "release-it"
+        "build": "echo"
     },
     "keywords": [
         "react-native",
@@ -62,124 +46,30 @@
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
     },
-    "devDependencies": {
-        "@commitlint/config-conventional": "^17.0.2",
-        "@evilmartians/lefthook": "^1.5.0",
-        "@react-native-community/cli": "15.0.1",
-        "@react-native/eslint-config": "^0.73.1",
-        "@release-it/conventional-changelog": "^9.0.2",
-        "@types/jest": "^29.5.5",
-        "@types/react": "^18.2.44",
-        "commitlint": "^17.0.2",
-        "del-cli": "^5.1.0",
-        "eslint": "^8.51.0",
-        "eslint-config-prettier": "^9.0.0",
-        "eslint-plugin-prettier": "^5.0.1",
-        "jest": "^29.7.0",
-        "prettier": "^3.0.3",
-        "react": "18.3.1",
-        "react-native": "0.76.5",
-        "react-native-builder-bob": "^0.32.0",
-        "release-it": "^17.10.0",
-        "turbo": "^1.10.7",
-        "typescript": "^5.2.2"
-    },
-    "resolutions": {
-        "@types/react": "^18.2.44"
-    },
-    "peerDependencies": {
-        "react": "*",
-        "react-native": "*"
-    },
-    "jest": {
-        "preset": "react-native",
-        "modulePathIgnorePatterns": [
-            "<rootDir>/example/node_modules",
-            "<rootDir>/lib/"
-        ]
-    },
-    "commitlint": {
-        "extends": [
-            "@commitlint/config-conventional"
-        ]
-    },
-    "release-it": {
-        "git": {
-            "commitMessage": "chore: release ${version}",
-            "tagName": "v${version}"
-        },
-        "npm": {
-            "publish": true
-        },
-        "github": {
-            "release": true
+    "codegenConfig": {
+        "name": "CalculatorKeyboardSpecs",
+        "type": "components",
+        "jsSrcsDir": "src",
+        "android": {
+            "javaPackageName": "com.calculatorkeyboard"
         },
-        "plugins": {
-            "@release-it/conventional-changelog": {
-                "preset": "angular"
+        "ios": {
+            "componentProvider": {
+                "NativeInputCalculator": "NativeInputCalculator"
             }
         }
     },
-    "eslintConfig": {
-        "root": true,
-        "extends": [
-            "@react-native",
-            "prettier"
-        ],
-        "rules": {
-            "react/react-in-jsx-scope": "off",
-            "prettier/prettier": [
-                "error",
-                {
-                    "quoteProps": "consistent",
-                    "singleQuote": true,
-                    "tabWidth": 2,
-                    "trailingComma": "es5",
-                    "useTabs": false
-                }
-            ]
-        }
-    },
-    "eslintIgnore": [
-        "node_modules/",
-        "lib/"
-    ],
-    "prettier": {
-        "quoteProps": "consistent",
-        "singleQuote": true,
-        "tabWidth": 2,
-        "trailingComma": "es5",
-        "useTabs": false
+    "devDependencies": {
+        "react": "19.0.0",
+        "react-native": "0.80.1"
     },
-    "react-native-builder-bob": {
-        "source": "src",
-        "output": "lib",
-        "targets": [
-            [
-                "commonjs",
-                {
-                    "esm": true
-                }
-            ],
-            [
-                "module",
-                {
-                    "esm": true
-                }
-            ],
-            [
-                "typescript",
-                {
-                    "project": "tsconfig.build.json",
-                    "esm": true
-                }
-            ]
-        ]
+    "peerDependencies": {
+        "react": "*",
+        "react-native": "*",
+        "@momo-kits/foundation": "latest"
     },
-    "create-react-native-library": {
-        "type": "legacy-view",
-        "languages": "kotlin-swift",
-        "version": "0.45.5"
+    "engines": {
+        "node": ">=18.0.0"
     },
     "dependencies": {}
 }

package/react-native-calculator-keyboard.podspec

@@ -5,7 +5,7 @@ folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1
 
 Pod::Spec.new do |s|
   s.name         = "react-native-calculator-keyboard"
-  s.version      = "0.0.1"
+  s.version      = package["version"]
   s.summary      = package["description"]
   s.homepage     = package["homepage"]
   s.license      = package["license"]
@@ -14,9 +14,10 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/wem2017/react-native-calculator-keyboard.git/react-native-calculator-keyboard.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
-  s.resources = "**/Assets/**/*.{json}"
-
+  s.source_files = "ios/**/*.{h,m,mm}"
+  # s.public_header_files = "ios/CalculatorKeyboardView.h"
+  # s.private_header_files = "ios/NativeInputCalculator.h"
+  
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
   if respond_to?(:install_modules_dependencies, true)

package/src/InputCalculatorNativeComponent.ts

@@ -0,0 +1,62 @@
+import type * as React from 'react';
+import type { HostComponent, ViewProps } from 'react-native';
+import {
+  CodegenTypes,
+  codegenNativeComponent,
+  codegenNativeCommands,
+} from 'react-native';
+
+export type CustomKeyBackground = 'primary' | 'default' | string;
+
+export enum CustomKeyState {
+  Default = 'default',
+  Disable = 'disable',
+}
+
+export enum Mode {
+  NumDefault = 'NumDefault',
+  NumWithCTA = 'NumWithCTA',
+}
+
+export type OnKeyPressEvent = Readonly<{
+  key: string;
+}>;
+
+export type OnChangeEvent = Readonly<{
+  text: string;
+}>;
+
+export type TextAttributes = Readonly<{
+  fontSize?: CodegenTypes.Float;
+  fontWeight?: string;
+}>;
+
+export interface NativeInputCalculatorProps extends ViewProps {
+  value?: string;
+  textAttributes?: TextAttributes;
+  mode?: string;
+  customKeyText?: string;
+  customKeyBackground?: string;
+  customKeyTextColor?: string;
+  customKeyState?: string;
+  onChange?: CodegenTypes.BubblingEventHandler<OnChangeEvent>;
+  onKeyPress?: CodegenTypes.BubblingEventHandler<OnKeyPressEvent>;
+  onCustomKeyEvent?: CodegenTypes.DirectEventHandler<{}>;
+}
+
+export interface NativeInputCalculatorCommands {
+  focus(
+    viewRef: React.ElementRef<HostComponent<NativeInputCalculatorProps>>,
+  ): void;
+  blur(
+    viewRef: React.ElementRef<HostComponent<NativeInputCalculatorProps>>,
+  ): void;
+}
+
+export const Commands = codegenNativeCommands<NativeInputCalculatorCommands>({
+  supportedCommands: ['focus', 'blur'],
+});
+
+export default codegenNativeComponent<NativeInputCalculatorProps>(
+  'NativeInputCalculator',
+);