react-native-keyboard-controller 1.17.5 → 1.18.0

package/ios/views/KeyboardBackgroundViewManager.mm

@@ -0,0 +1,168 @@
+//
+//  KeyboardBackgroundViewManager.mm
+//  Pods
+//
+//  Created by Kiryl Ziusko on 21/04/2025.
+//
+
+#import "KeyboardBackgroundViewManager.h"
+
+#if __has_include("react_native_keyboard_controller-Swift.h")
+#import "react_native_keyboard_controller-Swift.h"
+#else
+#import <react_native_keyboard_controller/react_native_keyboard_controller-Swift.h>
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <react/renderer/components/reactnativekeyboardcontroller/EventEmitters.h>
+#import <react/renderer/components/reactnativekeyboardcontroller/Props.h>
+#import <react/renderer/components/reactnativekeyboardcontroller/RCTComponentViewHelpers.h>
+#import <react/renderer/components/reactnativekeyboardcontroller/RNKCKeyboardBackgroundViewComponentDescriptor.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#endif
+
+#import <React/RCTView.h>
+#import <UIKit/UIKit.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+using namespace facebook::react;
+#endif
+
+typedef NS_ENUM(NSInteger, KeyboardBackdropStyle) {
+  KeyboardBackdropStyleDark = 2030,
+  KeyboardBackdropStyleLight = 3901
+};
+
+@protocol KeyboardBackdropViewProtocol <NSObject>
+@optional
+- (instancetype)initWithFrame:(CGRect)frame style:(long long)style;
+- (void)transitionToStyle:(long long)style;
+@end
+
+#pragma mark - Manager
+
+@implementation KeyboardBackgroundViewManager
+
+RCT_EXPORT_MODULE(KeyboardBackgroundViewManager)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+#ifndef RCT_NEW_ARCH_ENABLED
+- (UIView *)view
+{
+  RCTView *containerView = [[RCTView alloc] initWithFrame:CGRectZero];
+  containerView.clipsToBounds = YES;
+
+  KeyboardBackgroundView *backgroundView =
+      [[KeyboardBackgroundView alloc] initWithFrame:containerView.bounds];
+  backgroundView.autoresizingMask =
+      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  [containerView addSubview:backgroundView];
+
+  return containerView;
+}
+#endif
+
+@end
+
+#pragma mark - View
+
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface KeyboardBackgroundView () <RCTKeyboardBackgroundViewViewProtocol>
+#else
+@interface KeyboardBackgroundView ()
+#endif
+@end
+
+@implementation KeyboardBackgroundView {
+  UIVisualEffectView *_backdropView;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<KeyboardBackgroundViewComponentDescriptor>();
+}
+#endif
+
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
++ (void)load
+{
+  [super load];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  self = [super initWithFrame:frame];
+  if (self) {
+    [self setupBackdropView];
+  }
+  self.clipsToBounds = YES;
+  return self;
+}
+
+- (void)setupBackdropView
+{
+  Class BackdropClass = NSClassFromString(@"UIKBBackdropView");
+  if (BackdropClass) {
+    long long style = (self.traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark)
+        ? KeyboardBackdropStyleDark
+        : KeyboardBackdropStyleLight;
+
+    id<KeyboardBackdropViewProtocol> backdrop =
+        (id<KeyboardBackdropViewProtocol>)[BackdropClass alloc];
+    backdrop = [backdrop initWithFrame:self.bounds style:style];
+
+    if ([backdrop isKindOfClass:[UIVisualEffectView class]]) {
+      _backdropView = (UIVisualEffectView *)backdrop;
+      _backdropView.layer.masksToBounds = YES;
+      _backdropView.autoresizingMask =
+          UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+      _backdropView.frame = self.bounds;
+      [self addSubview:_backdropView];
+    }
+  } else {
+    NSLog(@"KeyboardBackdropView class not found");
+  }
+}
+
+// MARK: child management
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index
+{
+  // preserve slot 0 for blur layer
+  [super mountChildComponentView:childComponentView index:index + 1];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index
+{
+  // preserve slot 0 for blur layer
+  [super unmountChildComponentView:childComponentView index:index + 1];
+}
+#endif
+
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection
+{
+  [super traitCollectionDidChange:previousTraitCollection];
+
+  if (@available(iOS 12.0, *)) {
+    if ([previousTraitCollection
+            hasDifferentColorAppearanceComparedToTraitCollection:self.traitCollection]) {
+      long long style = (self.traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark)
+          ? KeyboardBackdropStyleDark
+          : KeyboardBackdropStyleLight;
+
+      if ([_backdropView respondsToSelector:@selector(transitionToStyle:)]) {
+        [(id<KeyboardBackdropViewProtocol>)_backdropView transitionToStyle:style];
+      }
+    }
+  }
+}
+
+@end

package/ios/views/KeyboardExtenderContainerView.swift

@@ -0,0 +1,59 @@
+//
+//  KeyboardExtenderContainerView.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 11/07/2025.
+//
+
+import UIKit
+
+@objc
+public class KeyboardExtenderContainerView: UIView {
+  @objc public static func create(frame: CGRect, contentView: UIView) -> UIView {
+    if #available(iOS 26.0, *) {
+      if let glassEffectClass = NSClassFromString("UIGlassEffect") as? UIVisualEffect.Type {
+        let paddingHorizontal = 20.0
+        let paddingBottom = 10.0
+        let isDark = FocusedInputHolder.shared.get()?.keyboardAppearanceValue == "dark"
+
+        let glassEffect = glassEffectClass.init()
+        let color = isDark ? UIColor.black.withAlphaComponent(0.3) : UIColor.gray.withAlphaComponent(0.3)
+        glassEffect.setValue(color, forKey: "tintColor")
+        glassEffect.setValue(true, forKey: "interactive")
+
+        // wrapper container will be full frame
+        let wrapperView = UIView(frame: frame)
+        wrapperView.backgroundColor = .clear
+
+        let innerWidth = frame.width - paddingHorizontal * 2
+        let innerHeight = frame.height
+
+        let visualEffectView = UIVisualEffectView(effect: glassEffect)
+        visualEffectView.overrideUserInterfaceStyle = isDark ? .dark : .light
+
+        visualEffectView.frame = CGRect(
+          x: paddingHorizontal,
+          y: -paddingBottom,
+          width: innerWidth,
+          height: innerHeight
+        )
+        contentView.frame = CGRect(
+          x: -paddingHorizontal,
+          y: 0,
+          width: innerWidth,
+          height: innerHeight
+        )
+
+        visualEffectView.contentView.addSubview(contentView)
+        wrapperView.addSubview(visualEffectView)
+
+        return wrapperView
+      }
+    }
+
+    let inputView = UIInputView(frame: frame, inputViewStyle: .keyboard)
+    contentView.frame = inputView.bounds
+    inputView.addSubview(contentView)
+    return inputView
+  }
+}

package/ios/views/KeyboardExtenderManager.h

@@ -0,0 +1,29 @@
+//
+//  KeyboardExtenderManager.h
+//  KeyboardController
+//
+//  Created by Kiryl Ziusko on 13.04.25.
+//  Copyright © 2025 Facebook. All rights reserved.
+//
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#else
+#import <React/RCTBridge.h>
+#endif
+#import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
+
+@interface KeyboardExtenderManager : RCTViewManager
+@end
+
+@interface KeyboardExtender :
+#ifdef RCT_NEW_ARCH_ENABLED
+    RCTViewComponentView
+#else
+    UIView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+#endif
+@property (nonatomic, assign) BOOL enabled;
+@end

package/ios/views/KeyboardExtenderManager.mm

@@ -0,0 +1,287 @@
+//
+//  KeyboardExtenderManager.mm
+//  react-native-keyboard-controller
+//
+//  Created by Kiryl Ziusko on 13/04/2025.
+//
+
+#import "KeyboardExtenderManager.h"
+
+#if __has_include("react_native_keyboard_controller-Swift.h")
+#import "react_native_keyboard_controller-Swift.h"
+#else
+#import <react_native_keyboard_controller/react_native_keyboard_controller-Swift.h>
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTSurfaceTouchHandler.h>
+
+#import <react/renderer/components/reactnativekeyboardcontroller/EventEmitters.h>
+#import <react/renderer/components/reactnativekeyboardcontroller/Props.h>
+#import <react/renderer/components/reactnativekeyboardcontroller/RCTComponentViewHelpers.h>
+#import <react/renderer/components/reactnativekeyboardcontroller/RNKCKeyboardExtenderComponentDescriptor.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#endif
+
+#import <React/RCTTouchHandler.h>
+#import <UIKit/UIKit.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+using namespace facebook::react;
+#endif
+
+// MARK: Manager
+@implementation KeyboardExtenderManager
+
+RCT_EXPORT_MODULE(KeyboardExtenderManager)
+
+// Expose the `enabled` prop to React Native
+RCT_EXPORT_VIEW_PROPERTY(enabled, BOOL)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+#ifndef RCT_NEW_ARCH_ENABLED
+- (UIView *)view
+{
+  return [[KeyboardExtender alloc] initWithBridge:self.bridge];
+}
+#endif
+
+@end
+
+// MARK: View
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface KeyboardExtender () <RCTKeyboardExtenderViewProtocol>
+@end
+#endif
+
+@implementation KeyboardExtender {
+  UIView *_contentView;
+  UIView *_sharedInputAccessoryView;
+#ifdef RCT_NEW_ARCH_ENABLED
+  RCTSurfaceTouchHandler *_touchHandler;
+#else
+  RCTTouchHandler *_touchHandler;
+#endif
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<KeyboardExtenderComponentDescriptor>();
+}
+#endif
+
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
++ (void)load
+{
+  [super load];
+}
+
+// MARK: Constructor
+#ifdef RCT_NEW_ARCH_ENABLED
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _touchHandler = [RCTSurfaceTouchHandler new];
+    _contentView = [[UIView alloc] initWithFrame:CGRectZero];
+  }
+#else
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  self = [super initWithFrame:CGRectZero];
+  if (self) {
+    _touchHandler = [[RCTTouchHandler alloc] initWithBridge:bridge];
+    _contentView = [[UIView alloc] initWithFrame:CGRectZero];
+  }
+#endif
+  [_touchHandler attachToView:_contentView];
+  [self setupObservers];
+  return self;
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+// MARK: Listeners
+- (void)setupObservers
+{
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleTextInputDidBeginEditing:)
+                                               name:UITextFieldTextDidBeginEditingNotification
+                                             object:nil];
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleTextInputDidBeginEditing:)
+                                               name:UITextViewTextDidBeginEditingNotification
+                                             object:nil];
+}
+
+- (void)handleTextInputDidBeginEditing:(NSNotification *)notification
+{
+  if (self.enabled) {
+    [self attachToTextInput:(UIView *)notification.object];
+  } else {
+    [self detachInputAccessoryView];
+  }
+}
+
+- (void)attachToTextInput:(UIView *)textInput
+{
+  if ([textInput isKindOfClass:[UITextField class]]) {
+    [self attachInputAccessoryViewTo:(UITextField *)textInput];
+  } else if ([textInput isKindOfClass:[UITextView class]]) {
+    [self attachInputAccessoryViewTo:(UITextView *)textInput];
+  }
+}
+
+- (void)createSharedInputAccessoryView
+{
+  CGRect internalFrame = _contentView.subviews[0].frame;
+  _sharedInputAccessoryView = [KeyboardExtenderContainerView
+      createWithFrame:CGRectMake(
+                          0, 0, UIScreen.mainScreen.bounds.size.width, internalFrame.size.height)
+          contentView:_contentView];
+}
+
+- (void)attachInputAccessoryViewTo:(UIView<UITextInput> *)input
+{
+  // Initialize the shared input accessory view once
+  if (!_sharedInputAccessoryView) {
+    [self createSharedInputAccessoryView];
+  }
+
+  // Assign the inputAccessoryView
+  if ([input isKindOfClass:[UITextField class]]) {
+    ((UITextField *)input).inputAccessoryView = _sharedInputAccessoryView;
+  } else if ([input isKindOfClass:[UITextView class]]) {
+    ((UITextView *)input).inputAccessoryView = _sharedInputAccessoryView;
+  }
+
+  // Refresh input view to apply changes
+  [input reloadInputViews];
+}
+
+- (void)detachInputAccessoryView
+{
+  // Remove the accessory view from the current text input
+  UIResponder *firstResponder = [UIResponder current];
+  if ([firstResponder isKindOfClass:[UITextField class]] ||
+      [firstResponder isKindOfClass:[UITextView class]]) {
+    UIView<UITextInput> *textInput = (UIView<UITextInput> *)firstResponder;
+    if (textInput.inputAccessoryView == _sharedInputAccessoryView) {
+      // Assign the inputAccessoryView
+      if ([textInput isKindOfClass:[UITextField class]]) {
+        ((UITextField *)textInput).inputAccessoryView = nil;
+      } else if ([textInput isKindOfClass:[UITextView class]]) {
+        ((UITextView *)textInput).inputAccessoryView = nil;
+      }
+      [textInput reloadInputViews];
+    }
+  }
+}
+
+// MARK: touch handling
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  BOOL canReceiveTouchEvents = ([self isUserInteractionEnabled] && ![self isHidden] && _enabled);
+  if (!canReceiveTouchEvents) {
+    return nil;
+  }
+
+  // `hitSubview` is the topmost subview which was hit. The hit point can
+  // be outside the bounds of `view` (e.g., if -clipsToBounds is NO).
+  UIView *hitSubview = nil;
+  BOOL isPointInside = [self pointInside:point withEvent:event];
+  if (![self clipsToBounds] || isPointInside) {
+    // TODO: should we take zIndex into consideration?
+    // The default behaviour of UIKit is that if a view does not contain a point,
+    // then no subviews will be returned from hit testing, even if they contain
+    // the hit point. By doing hit testing directly on the subviews, we bypass
+    // the strict containment policy (i.e., UIKit guarantees that every ancestor
+    // of the hit view will return YES from -pointInside:withEvent:). See:
+    //  - https://developer.apple.com/library/ios/qa/qa2013/qa1812.html
+    for (UIView *subview in [_contentView.subviews reverseObjectEnumerator]) {
+      CGPoint convertedPoint = [subview convertPoint:point fromView:self];
+      hitSubview = [subview hitTest:convertedPoint withEvent:event];
+      if (hitSubview != nil) {
+        break;
+      }
+    }
+  }
+  return hitSubview;
+}
+
+// MARK: props updater
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<const KeyboardExtenderProps>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<const KeyboardExtenderProps>(props);
+
+  if (newViewProps.enabled != oldViewProps.enabled) {
+    [self updateEnabledState:newViewProps.enabled];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+#else
+- (void)setEnabled:(BOOL)enabled
+{
+  _enabled = enabled;
+
+  [self updateEnabledState:enabled];
+}
+#endif
+
+- (void)updateEnabledState:(BOOL)enabled
+{
+  _enabled = enabled;
+
+  if (_sharedInputAccessoryView) {
+    if (!enabled) {
+      [self detachInputAccessoryView];
+    } else {
+      // Re-attach if a text input is active
+      UIResponder *firstResponder = [UIResponder current];
+      if ([firstResponder conformsToProtocol:@protocol(UITextInput)]) {
+        [self attachToTextInput:(UIView *)firstResponder];
+      }
+    }
+  }
+}
+
+// MARK: child management
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index
+{
+  [_contentView insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+#else
+- (void)addSubview:(UIView *)view
+{
+  [_contentView addSubview:view];
+}
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+Class<RCTComponentViewProtocol> KeyboardExtenderCls(void)
+{
+  return KeyboardExtender.class;
+}
+#endif
+
+@end

package/jest/index.js

@@ -51,7 +51,9 @@ const mock = {
   useGenericKeyboardHandler: jest.fn(),
   useKeyboardHandler: jest.fn(),
   useKeyboardContext: jest.fn().mockReturnValue(values),
-  useKeyboardState: jest.fn().mockReturnValue(state),
+  useKeyboardState: jest
+    .fn()
+    .mockImplementation((selector) => (selector ? selector(state) : state)),
   /// input
   useReanimatedFocusedInput: jest.fn().mockReturnValue(focusedInput),
   useFocusedInputHandler: jest.fn(),
@@ -65,6 +67,7 @@ const mock = {
   KeyboardController: {
     setInputMode: jest.fn(),
     setDefaultMode: jest.fn(),
+    preload: jest.fn(),
     dismiss: jest.fn().mockReturnValue(Promise.resolve()),
     setFocusTo: jest.fn(),
     isVisible: jest.fn().mockReturnValue(false),
@@ -93,6 +96,8 @@ const mock = {
   KeyboardControllerView: "KeyboardControllerView",
   KeyboardGestureArea: "KeyboardGestureArea",
   OverKeyboardView: "OverKeyboardView",
+  KeyboardBackgroundView: "KeyboardBackgroundView",
+  KeyboardExtender: "KeyboardExtender",
   // providers
   KeyboardProvider: "KeyboardProvider",
   // components

package/lib/commonjs/animated.js

@@ -12,7 +12,7 @@ var _bindings = require("./bindings");
 var _context = require("./context");
 var _eventMappings = require("./event-mappings");
 var _internal = require("./internal");
-var _monkeyPatch = require("./monkey-patch");
+var _module = require("./module");
 var _reanimated = require("./reanimated");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -53,7 +53,8 @@ const KeyboardProvider = props => {
     statusBarTranslucent,
     navigationBarTranslucent,
     preserveEdgeToEdge,
-    enabled: initiallyEnabled = true
+    enabled: initiallyEnabled = true,
+    preload = true
   } = props;
   // ref
   const viewTagRef = (0, _react.useRef)(null);
@@ -144,15 +145,11 @@ const KeyboardProvider = props => {
       }
     }
   }, []);
-
-  // layout effects
-  (0, _react.useLayoutEffect)(() => {
-    if (enabled) {
-      (0, _monkeyPatch.applyMonkeyPatch)();
-    } else {
-      (0, _monkeyPatch.revertMonkeyPatch)();
+  (0, _react.useEffect)(() => {
+    if (preload) {
+      _module.KeyboardController.preload();
     }
-  }, [enabled]);
+  }, [preload]);
   if (__DEV__) {
     (0, _reactNativeIsEdgeToEdge.controlEdgeToEdgeValues)({
       statusBarTranslucent,