react-native-external-keyboard 0.8.4 → 0.9.0-alpha.0

package/ios/Views/Base/FocusChange/RNCEKVViewFocusChangeBase.h

@@ -0,0 +1,37 @@
+//
+//  RNCEKVViewFocusChangeBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#ifndef RNCEKVViewFocusChangeBase_h
+#define RNCEKVViewFocusChangeBase_h
+
+#import "RNCEKVViewGroupIdentifierBase.h"
+#import "RNCEKVFocusDelegate.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#endif
+
+@interface RNCEKVViewFocusChangeBase : RNCEKVViewGroupIdentifierBase<RNCEKVFocusProtocol>
+
+@property BOOL canBeFocused;
+@property BOOL hasOnFocusChanged;
+@property (nonatomic, assign, readonly) BOOL isKeyboardFocused;
+
+
+@property (nonatomic, strong, readonly) RNCEKVFocusDelegate* focusDelegate;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusProps:(const RNCEKV::FocusProps &)oldProps
+newProps:(const RNCEKV::FocusProps &)newProps;
+#endif
+
+- (void)onFocusChangeHandler:(BOOL)isFocused;
+
+@end
+
+
+#endif /* RNCEKVViewFocusChangeBase_h */

package/ios/Views/Base/FocusChange/RNCEKVViewFocusChangeBase.mm

@@ -0,0 +1,88 @@
+//
+//  RNCEKVViewFocusChangeBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+
+
+#import "RNCEKVViewFocusChangeBase.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#import "RNCEKVFabricEventHelper.h"
+#endif
+//#import "RNCEKVFocusDelegate.h"
+
+@implementation RNCEKVViewFocusChangeBase {
+  NSNumber* _isFocused;
+}
+
+- (BOOL)isGroup {
+  return false;
+}
+
+- (BOOL)isKeyboardFocused {
+  return [_isFocused isEqual:@YES];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _focusDelegate = [[RNCEKVFocusDelegate alloc] initWithView:self];
+    _isFocused = nil;
+  }
+  
+  return self;
+}
+
+- (void)cleanReferences {
+  _isFocused = nil;
+  _canBeFocused = false;
+  _hasOnFocusChanged = false;
+}
+
+- (UIView *)getFocusTargetView {
+  return [_focusDelegate getFocusingView];
+}
+
+
+- (BOOL)canBecomeFocused {
+  if (!_canBeFocused)
+    NO;
+  return [_focusDelegate canBecomeFocused];
+}
+
+
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator {
+  _isFocused = [_focusDelegate isFocusChanged:context];
+
+  if ([self hasOnFocusChanged]) {
+    if (_isFocused != nil) {
+      [self onFocusChangeHandler:[_isFocused isEqual:@YES]];
+    }
+  }
+
+  [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+}
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusProps:(const RNCEKV::FocusProps &)oldProps
+                          newProps:(const RNCEKV::FocusProps &)newProps {
+  if (oldProps.canBeFocused != newProps.canBeFocused) {
+    [self setCanBeFocused:newProps.canBeFocused];
+  }
+  
+  if (_hasOnFocusChanged != newProps.hasOnFocusChanged) {
+    [self setHasOnFocusChanged:newProps.hasOnFocusChanged];
+  }
+}
+
+#endif
+
+- (void)onFocusChangeHandler:(BOOL)isFocused {}
+
+@end

package/ios/Views/Base/FocusOrderGroup/RNCEKVViewOrderGroupBase.h

@@ -0,0 +1,49 @@
+//
+//  RNCEKVViewOrderGroupBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 07/04/2026.
+//
+
+#ifndef RNCEKVViewOrderGroupBase_h
+#define RNCEKVViewOrderGroupBase_h
+
+#import <UIKit/UIKit.h>
+#import "RNCEKVViewGroupBase.h"
+#import "RNCEKVFocusOrderProtocol.h"
+#import "RNCEKVFocusOrderDelegate.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include "RNCEKVNativeProps.h"
+#endif
+
+@interface RNCEKVViewOrderGroupBase : RNCEKVViewGroupBase <RNCEKVFocusOrderProtocol>
+
+- (void)cleanReferences;
+
+
+@property (nonatomic, strong) NSString* orderGroup;
+@property (nonatomic, strong) NSNumber* lockFocus;
+@property (nonatomic, strong) NSNumber* orderPosition;
+@property (nonatomic, strong) NSString* orderLeft;
+@property (nonatomic, strong) NSString* orderRight;
+@property (nonatomic, strong) NSString* orderUp;
+@property (nonatomic, strong) NSString* orderDown;
+@property (nonatomic, strong) NSString* orderForward;
+@property (nonatomic, strong) NSString* orderBackward;
+@property (nonatomic, strong) NSString* orderLast;
+@property (nonatomic, strong) NSString* orderFirst;
+
+@property (nonatomic, strong) NSString* orderId;
+
+@property (nonatomic, strong, readonly) RNCEKVFocusOrderDelegate* focusOrderDelegate;
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusOrderProps:(const RNCEKV::OrderProps &)oldProps
+                     newProps:(const RNCEKV::OrderProps &)newProps;
+#endif
+
+@end
+
+#endif /* RNCEKVViewOrderGroupBase_h */

package/ios/Views/Base/FocusOrderGroup/RNCEKVViewOrderGroupBase.mm

@@ -0,0 +1,200 @@
+//
+//  RNCEKVViewOrderGroupBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 07/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVViewOrderGroupBase.h"
+#import "RNCEKVFocusOrderDelegate.h"
+#import "RNCEKVOrderLinking.h"
+#import "UIViewController+RNCEKVExternalKeyboard.h"
+#import "UIView+React.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include "RNCEKVNativeProps.h"
+#import "RNCEKVPropHelper.h"
+#endif
+
+@interface RNCEKVViewOrderGroupBase ()
+@property (nonatomic, strong, readwrite) RNCEKVFocusOrderDelegate* focusOrderDelegate;
+@end
+
+@implementation RNCEKVViewOrderGroupBase
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _focusOrderDelegate = [[RNCEKVFocusOrderDelegate alloc] initWithView:self];
+  }
+
+  return self;
+}
+
+- (BOOL)getIsViewFocused:(UIFocusUpdateContext *)context {
+  return context.nextFocusedView == [self getStoredView];
+}
+
+
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator {
+  BOOL isFocused = [self getIsViewFocused: context];
+  [_focusOrderDelegate setIsFocused: isFocused];
+
+  [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+}
+
+- (void)focus {
+  UIViewController *controller = self.reactViewController;
+  BOOL isAttached = self.superview != nil && controller != nil;
+
+  if (isAttached) {
+    [controller rncekvFocusView:[self getStoredView]];
+  }
+}
+
+- (void)cleanReferences {
+  [super cleanReferences];
+  [_focusOrderDelegate unlink];
+
+    _orderGroup = nil;
+    _orderPosition = nil;
+    _orderLeft = nil;
+    _orderRight = nil;
+    _orderUp = nil;
+    _orderDown = nil;
+    _orderForward = nil;
+    _orderBackward = nil;
+    _orderLast = nil;
+    _orderFirst = nil;
+    _orderId = nil;
+    _lockFocus = nil;
+}
+
+- (UIView *)getFocusTargetView {
+  return [self getStoredView];
+}
+
+- (void)didMoveToWindow {
+  if (self.window) {
+    [_focusOrderDelegate link];
+  } else {
+    [_focusOrderDelegate unlink];
+  }
+}
+
+- (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context {
+  NSNumber* result = [_focusOrderDelegate shouldUpdateFocusInContext: context];
+
+  if(result == nil) {
+    return [super shouldUpdateFocusInContext: context];
+  }
+
+  return result.boolValue;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusOrderProps:(const RNCEKV::OrderProps &)oldViewProps
+                     newProps:(const RNCEKV::OrderProps &)newViewProps {
+  if ((oldViewProps.lockFocus != newViewProps.lockFocus)) {
+    NSNumber* lockValue = [RNCEKVPropHelper unwrapIntValue: newViewProps.lockFocus];
+    [self setLockFocus: lockValue];
+  }
+
+  if ((oldViewProps.orderIndex != newViewProps.orderIndex)) {
+    NSNumber* position = [RNCEKVPropHelper unwrapIntValue: newViewProps.orderIndex];
+    [self setOrderPosition: position];
+  }
+
+  if ((oldViewProps.orderGroup != newViewProps.orderGroup)) {
+    NSString* orderGroup = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderGroup];
+    [self setOrderGroup: orderGroup];
+  }
+
+  if ((oldViewProps.orderId != newViewProps.orderId)) {
+    NSString* orderId = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderId];
+    [self setOrderId: orderId];
+  }
+
+  if ((oldViewProps.orderLeft != newViewProps.orderLeft)) {
+    NSString* orderLeft = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderLeft];
+    [self setOrderLeft: orderLeft];
+  }
+
+  if ((oldViewProps.orderRight != newViewProps.orderRight)) {
+    NSString* orderRight = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderRight];
+    [self setOrderRight: orderRight];
+  }
+
+  if ((oldViewProps.orderUp != newViewProps.orderUp)) {
+    NSString* orderUp = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderUp];
+    [self setOrderUp: orderUp];
+  }
+
+  if ((oldViewProps.orderDown != newViewProps.orderDown)) {
+    NSString* orderDown = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderDown];
+    [self setOrderDown: orderDown];
+  }
+
+  if ((oldViewProps.orderForward != newViewProps.orderForward)) {
+    NSString* orderForward = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderForward];
+    [self setOrderForward: orderForward];
+  }
+
+  if ((oldViewProps.orderBackward != newViewProps.orderBackward)) {
+    NSString* orderBackward = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderBackward];
+    [self setOrderBackward: orderBackward];
+  }
+
+  if ((oldViewProps.orderLast != newViewProps.orderLast)) {
+    NSString* orderLast = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderLast];
+    [self setOrderLast: orderLast];
+  }
+
+  if ((oldViewProps.orderFirst != newViewProps.orderFirst)) {
+    NSString* orderFirst = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderFirst];
+    [self setOrderFirst: orderFirst];
+  }
+}
+#endif
+
+
+- (void)setOrderGroup:(NSString *)orderGroup {
+  [_focusOrderDelegate updateOrderGroup: orderGroup];
+  _orderGroup = orderGroup;
+}
+
+
+- (void)setOrderId:(NSString *)next {
+  [_focusOrderDelegate refreshId:_orderId next:next];
+  _orderId = next;
+}
+
+- (void)setOrderLeft:(NSString *)orderLeft {
+  [_focusOrderDelegate refreshLeft: _orderLeft next: orderLeft];
+  _orderLeft = orderLeft;
+}
+
+- (void)setOrderRight:(NSString *)orderRight {
+  [_focusOrderDelegate refreshRight: _orderRight next: orderRight];
+  _orderRight = orderRight;
+}
+
+- (void)setOrderUp:(NSString *)orderUp {
+  [_focusOrderDelegate refreshUp: _orderUp next: orderUp];
+  _orderUp = orderUp;
+}
+
+- (void)setOrderDown:(NSString *)orderDown {
+  [_focusOrderDelegate refreshDown: _orderDown next: orderDown];
+  _orderDown = orderDown;
+}
+
+
+- (void)setOrderPosition:(NSNumber *)position {
+  [_focusOrderDelegate updatePosition: position];
+  _orderPosition = position;
+}
+
+@end

package/ios/Views/Base/FocusRequest/RNCEKVViewFocusRequestBase.h

@@ -0,0 +1,34 @@
+//
+//  RNCEKVViewFocusRequestBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#ifndef RNCEKVViewFocusRequestBase_h
+#define RNCEKVViewFocusRequestBase_h
+
+
+#import "RNCEKVViewContextMenuBase.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#endif
+
+@interface RNCEKVViewFocusRequestBase : RNCEKVViewContextMenuBase
+
+@property BOOL autoFocus;
+@property BOOL enableA11yFocus;
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusRequestProps:(const RNCEKV::AutoFocusProps &)oldProps
+newProps:(const RNCEKV::AutoFocusProps &)newProps;
+
+#endif
+
+- (void)focus;
+
+@end
+
+#endif /* RNCEKVViewFocusRequestBase_h */

package/ios/Views/Base/FocusRequest/RNCEKVViewFocusRequestBase.mm

@@ -0,0 +1,117 @@
+//
+//  RNCEKVViewFocusRequestBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+#import "UIViewController+RNCEKVExternalKeyboard.h"
+
+#import "UIView+React.h"
+#import "RNCEKVViewFocusRequestBase.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#import "RNCEKVFabricEventHelper.h"
+#endif
+
+@implementation RNCEKVViewFocusRequestBase {
+  BOOL _isAttachedToWindow;
+  BOOL _autoFocusRequested;
+  BOOL _enableA11yFocus;
+}
+
+- (void)cleanReferences {
+  [super cleanReferences];
+  _isAttachedToWindow = NO;
+  _enableA11yFocus = NO;
+  _autoFocusRequested = NO;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _isAttachedToWindow = NO;
+    _autoFocusRequested = NO;
+  }
+
+  return self;
+}
+
+- (void)focus {
+  
+  UIViewController *controller = self.reactViewController;
+  if (controller != nil) {
+    [controller rncekvFocusView: self];
+  }
+  
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self a11yFocus];
+  });
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusRequestProps:(const RNCEKV::AutoFocusProps &)oldProps
+newProps:(const RNCEKV::AutoFocusProps &)newProps {
+    if (oldProps.autoFocus != newProps.autoFocus) {
+      [self setAutoFocus: newProps.autoFocus];
+    }
+  
+  if (_enableA11yFocus != newProps.enableA11yFocus) {
+    [self setEnableA11yFocus: newProps.enableA11yFocus];
+  }
+}
+
+
+#endif
+
+
+- (void)onAttached
+{
+  [self focusOnMount];
+}
+
+
+- (void)onViewAttached {
+  if (self.autoFocus) {
+    [self focus];
+  }
+}
+
+- (void)a11yFocus {
+  if (!_enableA11yFocus)
+    return;
+  UIView *focusView = [self getFocusTargetView];
+  UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification,
+                                  focusView);
+}
+
+- (void)focusOnMount {
+  if (self.autoFocus) {
+    if(!_autoFocusRequested) {
+      _autoFocusRequested = YES;
+      dispatch_async(dispatch_get_main_queue(), ^{
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [self focus];
+        });
+      });
+    }
+  }
+}
+
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+
+  if (self.window) {
+    [self onAttached];
+  }
+
+  if (self.window && !_isAttachedToWindow) {
+    [self onViewAttached];
+    _isAttachedToWindow = YES;
+  }
+}
+
+
+@end

package/ios/Views/Base/GroupIdentifier/RNCEKVViewGroupIdentifierBase.h

@@ -0,0 +1,27 @@
+//
+//  RNCEKVViewGroupIdentifierBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#ifndef RNCEKVViewGroupIdentifierBase_h
+#define RNCEKVViewGroupIdentifierBase_h
+
+#import "RNCEKVExternalKeyboardHalloBase.h"
+#import "RNCEKVGroupIdentifierProtocol.h"
+#import "RNCEKVCustomGroudIdProtocol.h"
+
+@interface RNCEKVViewGroupIdentifierBase : RNCEKVExternalKeyboardHalloBase<RNCEKVGroupIdentifierProtocol, RNCEKVCustomGroudIdProtocol>
+
+@property (nonatomic, strong, nullable) NSString *customGroupId;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateGroupIdentifierProps:(const RNCEKV::GroupIdentifierProps &)oldProps
+                     newProps:(const RNCEKV::GroupIdentifierProps &)newProps;
+#endif
+
+@end
+
+
+#endif /* RNCEKVViewGroupIdentifierBase_h */

package/ios/Views/Base/GroupIdentifier/RNCEKVViewGroupIdentifierBase.mm

@@ -0,0 +1,61 @@
+//
+//  RNCEKVViewGroupIdentifierBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVViewGroupIdentifierBase.h"
+#import "RNCEKVGroupIdentifierDelegate.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include "RNCEKVNativeProps.h"
+#import "RNCEKVPropHelper.h"
+#endif
+
+@implementation RNCEKVViewGroupIdentifierBase {
+  RNCEKVGroupIdentifierDelegate *_gIdDelegate;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _gIdDelegate = [[RNCEKVGroupIdentifierDelegate alloc] initWithView: self];
+  }
+  
+  return self;
+}
+
+- (NSString*)customGroupIdentifier {
+  return [_gIdDelegate getFocusGroupIdentifier];
+}
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateGroupIdentifierProps:(const RNCEKV::GroupIdentifierProps &)oldProps
+                          newProps:(const RNCEKV::GroupIdentifierProps &)newProps {
+  if (newProps.groupIdentifier.empty() && self.customGroupId != nil) {
+    self.customGroupId = nil;
+  }
+  
+  
+  NSString* newGroupId = [RNCEKVPropHelper unwrapStringValue: newProps.groupIdentifier];
+  
+  if(![_customGroupId isEqual: newGroupId]) {
+    [self setCustomGroupId: newGroupId];
+  }
+}
+#endif
+
+- (void) setCustomGroupId:(NSString *)customGroupId {
+  _customGroupId = customGroupId;
+}
+
+- (void)cleanReferences {
+  [super cleanReferences];
+  _customGroupId = nil;
+}
+
+
+@end

package/ios/Views/Base/KeyPress/RNCEKVViewKeyPress.h

@@ -0,0 +1,30 @@
+//
+//  RNCEKVViewKeyPress.h
+//  Pods
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#ifndef RNCEKVViewKeyPress_h
+#define RNCEKVViewKeyPress_h
+
+#import "RNCEKVViewFocusRequestBase.h"
+
+@interface RNCEKVViewKeyPress : RNCEKVViewFocusRequestBase
+
+@property BOOL hasOnPressUp;
+@property BOOL hasOnPressDown;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateKeyPressProps:(const RNCEKV::KeyPressProps &)oldProps
+                   newProps:(const RNCEKV::KeyPressProps &)newProps;
+
+#endif
+
+- (void)onKeyDownPressHandler:(NSDictionary *)eventInfo;
+- (void)onKeyUpPressHandler:(NSDictionary *)eventInfo;
+
+@end
+
+
+#endif /* RNCEKVViewKeyPress_h */