react-native-ui-lib 7.46.0 → 7.46.1-snapshot.7298

package/lib/components/SafeArea/__tests__/SafeAreaInsetsManager.spec.js

@@ -0,0 +1,274 @@
+import {NativeModules, DeviceEventEmitter} from 'react-native';
+import {DEFAULT_INSETS} from '../SafeAreaInsetsManager';
+
+const MOCKED_INSETS = {top: 44, left: 0, bottom: 34, right: 0};
+
+describe('SafeAreaInsetsManager', () => {
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+
+    // Reset the SafeAreaInsetsCache by creating a fresh instance
+    jest.resetModules();
+
+    // Spy on console methods to verify logging
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+    jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore console methods
+    jest.restoreAllMocks();
+  });
+
+  describe('getSafeAreaInsets', () => {
+    it('should return default insets when native module is not available', async () => {
+      // Arrange
+      NativeModules.SafeAreaManager = null;
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result).toEqual(DEFAULT_INSETS);
+      expect(console.log).toHaveBeenCalledWith('SafeAreaInsetsManager: Native SafeAreaManager not available, using defaults');
+    });
+
+    it('should return insets from native module when available', async () => {
+      // Arrange
+      const mockInsets = {top: 50, left: 10, bottom: 30, right: 10};
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockResolvedValue(mockInsets)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result).toEqual(mockInsets);
+      expect(NativeModules.SafeAreaManager.getSafeAreaInsets).toHaveBeenCalled();
+    });
+
+    it.skip('should return cached insets on subsequent calls', async () => {
+      // Arrange
+      const mockInsets = MOCKED_INSETS;
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockResolvedValue(mockInsets)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result1 = await SafeAreaInsetsManager.getSafeAreaInsets();
+      const result2 = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result1).toEqual(mockInsets);
+      expect(result2).toEqual(mockInsets);
+      expect(NativeModules.SafeAreaManager.getSafeAreaInsets).toHaveBeenCalledTimes(1); // Should only call native once due to caching
+    });
+
+    it('should handle native module errors gracefully', async () => {
+      // Arrange
+      const mockError = new Error('Native module error');
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockRejectedValue(mockError)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result).toEqual(DEFAULT_INSETS); // Should fallback to defaults
+      expect(console.warn).toHaveBeenCalledWith('SafeAreaInsetsManager: Failed to get initial insets:', mockError);
+      expect(console.warn).toHaveBeenCalledWith('SafeAreaInsetsManager: Failed to get native insets:', mockError);
+    });
+
+    it('should handle native module setup errors gracefully', async () => {
+      // Arrange
+      Object.defineProperty(NativeModules, 'SafeAreaManager', {
+        get: () => {
+          throw new Error('Setup error');
+        }
+      });
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result).toEqual(DEFAULT_INSETS); // Should fallback to defaults
+      expect(console.warn).toHaveBeenCalledWith('SafeAreaInsetsManager: Failed to connect to native module:', expect.any(Error));
+    });
+
+    it('should update insets when they change during the test', async () => {
+      // Arrange
+      const initialInsets = MOCKED_INSETS;
+      const updatedInsets = {top: 50, left: 0, bottom: 40, right: 0};
+
+      NativeModules.SafeAreaManager = {
+        // TODO: this will need to be changed when the we get caching to work in tests ("should return cached insets on subsequent calls")
+        // getSafeAreaInsets: jest.fn().mockResolvedValueOnce(initialInsets).mockResolvedValueOnce(updatedInsets)
+        getSafeAreaInsets: jest
+          .fn()
+          .mockResolvedValueOnce(initialInsets)
+          .mockResolvedValueOnce(initialInsets)
+          .mockResolvedValueOnce(updatedInsets)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act & Assert - Initial insets
+      const result1 = await SafeAreaInsetsManager.getSafeAreaInsets();
+      expect(result1).toEqual(initialInsets);
+
+      // Force refresh of insets
+      await SafeAreaInsetsManager.refreshSafeAreaInsets();
+
+      // Simulate insets change event from native side
+      DeviceEventEmitter.emit('SafeAreaInsetsDidChangeEvent', updatedInsets);
+
+      // Get insets again - should reflect the change
+      const result2 = await SafeAreaInsetsManager.getSafeAreaInsets();
+      expect(result2).toEqual(updatedInsets);
+    });
+
+    it('should notify delegates when insets change during the test', async () => {
+      // Arrange
+      const initialInsets = MOCKED_INSETS;
+      const updatedInsets = {top: 50, left: 0, bottom: 40, right: 0};
+
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockResolvedValue(initialInsets)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Add a mock delegate
+      const mockDelegate = {
+        onSafeAreaInsetsDidChangeEvent: jest.fn()
+      };
+      SafeAreaInsetsManager.addSafeAreaChangedDelegate(mockDelegate);
+
+      // Act - Get initial insets
+      await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Simulate insets change event from native side
+      DeviceEventEmitter.emit('SafeAreaInsetsDidChangeEvent', updatedInsets);
+
+      // Assert - Delegate should be notified
+      expect(mockDelegate.onSafeAreaInsetsDidChangeEvent).toHaveBeenCalledWith(updatedInsets);
+    });
+
+    it('should handle refreshSafeAreaInsets correctly', async () => {
+      // Arrange
+      const initialInsets = MOCKED_INSETS;
+      const refreshedInsets = {top: 48, left: 0, bottom: 36, right: 0};
+
+      NativeModules.SafeAreaManager = {
+        // TODO: this will need to be changed when the we get caching to work in tests ("should return cached insets on subsequent calls")
+        // getSafeAreaInsets: jest.fn().mockResolvedValueOnce(initialInsets).mockResolvedValueOnce(updatedInsets)
+        getSafeAreaInsets: jest
+          .fn()
+          .mockResolvedValueOnce(initialInsets)
+          .mockResolvedValueOnce(initialInsets)
+          .mockResolvedValueOnce(refreshedInsets)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result1 = await SafeAreaInsetsManager.getSafeAreaInsets();
+      expect(result1).toEqual(initialInsets);
+
+      // Refresh insets
+      await SafeAreaInsetsManager.refreshSafeAreaInsets();
+
+      const result2 = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result2).toEqual(refreshedInsets);
+      // TODO: this will need to be changed when the we get caching to work in tests ("should return cached insets on subsequent calls")
+      expect(NativeModules.SafeAreaManager.getSafeAreaInsets).toHaveBeenCalledTimes(3);
+    });
+
+    it('should not notify delegates when insets remain the same after refresh', async () => {
+      // Arrange
+      const sameInsets = MOCKED_INSETS;
+
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockResolvedValue(sameInsets)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Add a mock delegate
+      const mockDelegate = {
+        onSafeAreaInsetsDidChangeEvent: jest.fn()
+      };
+      SafeAreaInsetsManager.addSafeAreaChangedDelegate(mockDelegate);
+
+      // Act
+      await SafeAreaInsetsManager.getSafeAreaInsets();
+      await SafeAreaInsetsManager.refreshSafeAreaInsets();
+
+      // TODO: this will need to be changed when the we get caching to work in tests ("should return cached insets on subsequent calls")
+      expect(NativeModules.SafeAreaManager.getSafeAreaInsets).toHaveBeenCalledTimes(3);
+
+      // Assert - Delegate should not be notified since insets didn't change
+      expect(mockDelegate.onSafeAreaInsetsDidChangeEvent).not.toHaveBeenCalled();
+    });
+
+    it('should return default insets when native getSafeAreaInsets returns null', async () => {
+      // Arrange
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockResolvedValue(null)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      // Act
+      const result = await SafeAreaInsetsManager.getSafeAreaInsets();
+
+      // Assert
+      expect(result).toEqual(DEFAULT_INSETS);
+    });
+
+    it('should properly manage delegate lifecycle', async () => {
+      // Arrange
+      NativeModules.SafeAreaManager = {
+        getSafeAreaInsets: jest.fn().mockResolvedValue(MOCKED_INSETS)
+      };
+
+      const SafeAreaInsetsManager = require('../SafeAreaInsetsManager').default;
+
+      const mockDelegate1 = {
+        onSafeAreaInsetsDidChangeEvent: jest.fn()
+      };
+      const mockDelegate2 = {
+        onSafeAreaInsetsDidChangeEvent: jest.fn()
+      };
+
+      // Act
+      SafeAreaInsetsManager.addSafeAreaChangedDelegate(mockDelegate1);
+      SafeAreaInsetsManager.addSafeAreaChangedDelegate(mockDelegate2);
+
+      // Remove one delegate
+      SafeAreaInsetsManager.removeSafeAreaChangedDelegate(mockDelegate1);
+
+      // Trigger notification
+      const newInsets = MOCKED_INSETS;
+      SafeAreaInsetsManager.notifyDelegates(newInsets);
+
+      // Assert
+      expect(mockDelegate1.onSafeAreaInsetsDidChangeEvent).not.toHaveBeenCalled();
+      expect(mockDelegate2.onSafeAreaInsetsDidChangeEvent).toHaveBeenCalledWith(newInsets);
+    });
+  });
+});

package/lib/components/SafeArea/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ViewStyle, StyleProp } from 'react-native';
+export type SafeAreaSpacerViewProps = {
+    style?: StyleProp<ViewStyle>;
+};
+declare const SafeAreaSpacerView: {
+    ({ style }: SafeAreaSpacerViewProps): React.JSX.Element;
+    displayName: string;
+};
+export default SafeAreaSpacerView;

package/lib/components/SafeArea/index.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { View, Platform } from 'react-native';
+import SafeAreaSpacerViewIos from "./SafeAreaSpacerView";
+const isIOS = Platform.OS === 'ios';
+const SafeAreaSpacerView = ({
+  style
+}) => {
+  return isIOS ? <SafeAreaSpacerViewIos style={style} /> : <View style={style} />;
+};
+SafeAreaSpacerView.displayName = 'SafeAreaSpacerView';
+export default SafeAreaSpacerView;

package/lib/components/index.d.ts

@@ -1,6 +1,6 @@
 import DynamicFonts, { FontExtension } from './DynamicFonts';
 import HighlighterOverlayView from './HighlighterOverlayView';
-import SafeAreaSpacerView from './SafeArea/SafeAreaSpacerView';
+import SafeAreaSpacerView from './SafeArea';
 import SafeAreaInsetsManager from './SafeArea/SafeAreaInsetsManager';
 import Keyboard, { KeyboardTrackingViewProps, KeyboardAccessoryViewProps } from './Keyboard';
 export { DynamicFonts, FontExtension, HighlighterOverlayView, SafeAreaSpacerView, SafeAreaInsetsManager, Keyboard, KeyboardTrackingViewProps, KeyboardAccessoryViewProps };

package/lib/components/index.js

@@ -1,6 +1,6 @@
 import DynamicFonts, { FontExtension } from "./DynamicFonts";
 import HighlighterOverlayView from "./HighlighterOverlayView";
-import SafeAreaSpacerView from "./SafeArea/SafeAreaSpacerView";
+import SafeAreaSpacerView from "./SafeArea";
 import SafeAreaInsetsManager from "./SafeArea/SafeAreaInsetsManager";
 import Keyboard, { KeyboardTrackingViewProps, KeyboardAccessoryViewProps } from "./Keyboard";
 export { DynamicFonts, FontExtension, HighlighterOverlayView, SafeAreaSpacerView, SafeAreaInsetsManager, Keyboard, KeyboardTrackingViewProps, KeyboardAccessoryViewProps };

package/lib/ios/reactnativeuilib/keyboardinput/rctcustomInputcontroller/RCTCustomInputControllerTemp.m

@@ -13,6 +13,8 @@
 
 #import "LNAnimatorTemp.h"
 
+#import "RNNAppDelegate.h"
+
 #define kHlperViewTag 0x1f1f1f
 
 NSString *const RCTCustomInputControllerKeyboardResigendEventTemp = @"kbdResigned";
@@ -49,7 +51,6 @@ NSString *const RCTCustomInputControllerKeyboardResigendEventTemp = @"kbdResigne
         {
             [self.delegate _WXInputHelperViewResignFirstResponder:self];
         }
-
     }
     
     return rv;
@@ -118,17 +119,36 @@ RCT_EXPORT_MODULE(CustomInputControllerTemp)
     return [params[@"useSafeArea"] isEqual:@(1)];
 }
 
+- (UITextField*)getTextFieldFromTextInputComponentView:(id)inputField {
+    UITextField *textField = nil;
+    
+    if ([inputField isKindOfClass:NSClassFromString(@"RCTTextInputComponentView")])
+    {
+        Ivar textFieldIvar = class_getInstanceVariable([inputField class], "_backedTextInputView");
+        if (textFieldIvar != NULL)
+        {
+            textField = [inputField valueForKey:@"_backedTextInputView"];
+        }
+    }
+    
+    return textField;
+}
+
 RCT_EXPORT_METHOD(presentCustomInputComponent:(nonnull NSNumber*)inputFieldTag params:(nonnull NSDictionary*)params)
 {
     RCTBridge* bridge = [self.bridge valueForKey:@"parentBridge"];
     if(bridge == nil)
     {
-        return;
+        bridge = self.bridge;
     }
     
     UIView* inputField = [self.bridge.uiManager viewForReactTag:inputFieldTag];
     NSDictionary *initialProps = params[@"initialProps"];
-    RCTRootView* rv = [[RCTRootView alloc] initWithBridge:bridge moduleName:params[@"component"] initialProperties:initialProps];
+    
+    RNNAppDelegate* appDelegate = (RNNAppDelegate*)[UIApplication sharedApplication].delegate;
+    UIView *rv = [appDelegate.rootViewFactory viewWithModuleName:params[@"component"]
+                                                      initialProperties:initialProps];
+    
     if(initialProps != nil && initialProps[@"backgroundColor"] != nil)
     {
         UIColor *backgroundColor = [RCTConvert UIColor:initialProps[@"backgroundColor"]];
@@ -148,7 +168,17 @@ RCT_EXPORT_METHOD(presentCustomInputComponent:(nonnull NSNumber*)inputFieldTag p
     helperView.tag = kHlperViewTag;
     helperView.delegate = self;
     
-    if ([inputField isKindOfClass:NSClassFromString(@"RCTTextView")])
+    
+    
+    if ([inputField isKindOfClass:NSClassFromString(@"RCTTextInputComponentView")])
+    {
+        UITextField *textField = [self getTextFieldFromTextInputComponentView:inputField];
+        if (textField != nil)
+        {
+            helperView.inputAccessoryView = textField.inputAccessoryView;
+        }
+    }
+    else if ([inputField isKindOfClass:NSClassFromString(@"RCTTextView")])
     {
         UITextView *textView = nil;
         Ivar backedTextInputIvar = class_getInstanceVariable([inputField class], "_backedTextInput");
@@ -213,7 +243,17 @@ RCT_EXPORT_METHOD(resetInput:(nonnull NSNumber*)inputFieldTag)
         _WXInputHelperViewTemp* helperView = [inputField.superview viewWithTag:kHlperViewTag];
         if(helperView != nil && [helperView isFirstResponder])
         {//restore the first responder only if it was already the first responder to prevent the keyboard from opening again if not necessary
-            [inputField reactFocus];
+            if ([inputField isKindOfClass:NSClassFromString(@"RCTTextInputComponentView")])
+            {
+                UITextField *textField = [self getTextFieldFromTextInputComponentView:inputField];
+                if (textField != nil)
+                {
+                    [textField reactFocus];
+                }
+                
+            } else {
+                [inputField reactFocus];
+            }
         }
     }
 }
@@ -251,7 +291,7 @@ RCT_EXPORT_METHOD(dismissKeyboard)
     }
 }
 
--(UIColor*)reactViewAvgColor:(RCTRootView*)rootView
+-(UIColor*)reactViewAvgColor:(UIView*)rootView
 {
     if (rootView.frame.size.width == 0 || rootView.frame.size.height == 0)
     {
@@ -296,7 +336,7 @@ RCT_EXPORT_METHOD(expandFullScreenForInput:(nonnull NSNumber*)inputFieldTag)
             helperView.keepInSuperviewOnResign = YES;
             
             RCTCustomKeyboardViewControllerTemp *customKeyboardViewController = (RCTCustomKeyboardViewControllerTemp*)helperView.inputViewController;
-            RCTRootView *rv = customKeyboardViewController.rootView;
+            UIView *rv = customKeyboardViewController.rootView;
             UIInputView *inputView = helperView.inputViewController.inputView;
             
             _fullScreenWindow = [[UIWindow alloc] initWithFrame:[inputView.window convertRect:inputView.bounds fromView:inputView]];
@@ -370,7 +410,7 @@ RCT_EXPORT_METHOD(resetSizeForInput:(nonnull NSNumber*)inputFieldTag)
                             completionHandler:^(BOOL completed)
             {
                 RCTCustomKeyboardViewControllerTemp *customKeyboardViewController = (RCTCustomKeyboardViewControllerTemp*)helperView.inputViewController;
-                RCTRootView *rv = (RCTRootView*)_fullScreenWindow.rootViewController.view;
+                UIView *rv = _fullScreenWindow.rootViewController.view;
                 
                 [UIView performWithoutAnimation:^{
                     
@@ -388,6 +428,8 @@ RCT_EXPORT_METHOD(resetSizeForInput:(nonnull NSNumber*)inputFieldTag)
     }
 }
 
+
+
 #pragma mark - _WXInputHelperViewDelegateTemp methods
 
 -(void)_WXInputHelperViewResignFirstResponder:(UIView*)wxInputHelperView
@@ -397,6 +439,8 @@ RCT_EXPORT_METHOD(resetSizeForInput:(nonnull NSNumber*)inputFieldTag)
         [self sendEventWithName:RCTCustomInputControllerKeyboardResigendEventTemp body:nil];
     }
     self.customInputComponentPresented = NO;
+    
+    
 }
 
 @end

package/lib/ios/reactnativeuilib/keyboardinput/rctcustomInputcontroller/RCTCustomKeyboardViewControllerTemp.h

@@ -7,18 +7,12 @@
 
 #import <UIKit/UIKit.h>
 
-#if __has_include(<React/RCTRootView.h>)
-#import <React/RCTRootView.h>
-#else
-#import "RCTRootView.h"
-#endif
-
 @interface RCTCustomKeyboardViewControllerTemp : UIInputViewController
 
 - (void) setAllowsSelfSizing:(BOOL)allowsSelfSizing;
 - (instancetype)initWithUsingSafeArea:(BOOL)useSafeArea;
 
 @property (nonatomic, strong) NSLayoutConstraint *heightConstraint;
-@property (nonatomic, strong) RCTRootView *rootView;
+@property (nonatomic, strong) UIView *rootView;
 
 @end

package/lib/ios/reactnativeuilib/keyboardinput/rctcustomInputcontroller/RCTCustomKeyboardViewControllerTemp.m

@@ -57,7 +57,7 @@
     }
 }
 
--(void)setRootView:(RCTRootView*)rootView
+-(void)setRootView:(UIView*)rootView
 {
     if(_rootView != nil)
     {