react-native-ui-lib 8.1.1 → 8.1.5

package/lib/ios/reactnativeuilib/keyboardtrackingview/ObservingInputAccessoryViewTemp.h

@@ -0,0 +1,44 @@
+//
+//  ObservingInputAccessoryViewTemp.h
+//  ReactNativeChat
+//
+//  Created by Artal Druk on 11/04/2016.
+//  Copyright © 2016 Wix.com All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+typedef NS_ENUM(NSUInteger, KeyboardState) {
+    KeyboardStateHidden,
+    KeyboardStateWillShow,
+    KeyboardStateShown,
+    KeyboardStateWillHide
+};
+
+@class ObservingInputAccessoryViewTemp;
+
+@interface ObservingInputAccessoryViewTempManager : NSObject;
++(ObservingInputAccessoryViewTempManager*)sharedInstance;
+@property (nonatomic, weak) ObservingInputAccessoryViewTemp *activeObservingInputAccessoryViewTemp;
+@end
+
+@protocol ObservingInputAccessoryViewTempDelegate <NSObject>
+
+- (void)ObservingInputAccessoryViewTempDidChangeFrame:(ObservingInputAccessoryViewTemp*)ObservingInputAccessoryViewTemp;
+
+@optional
+
+- (void)ObservingInputAccessoryViewTempKeyboardWillAppear:(ObservingInputAccessoryViewTemp*)ObservingInputAccessoryViewTemp keyboardDelta:(CGFloat)delta;
+- (void)ObservingInputAccessoryViewTempKeyboardWillDisappear:(ObservingInputAccessoryViewTemp*)ObservingInputAccessoryViewTemp;
+
+@end
+
+@interface ObservingInputAccessoryViewTemp : UIView
+
+@property (nonatomic, weak) id<ObservingInputAccessoryViewTempDelegate> delegate;
+
+@property (nonatomic) CGFloat height;
+@property (nonatomic, readonly) CGFloat keyboardHeight;
+@property (nonatomic, readonly) KeyboardState keyboardState;
+
+@end

package/lib/ios/reactnativeuilib/keyboardtrackingview/ObservingInputAccessoryViewTemp.m

@@ -0,0 +1,171 @@
+//
+//  ObservingInputAccessoryViewTemp.m
+//  ReactNativeChat
+//
+//  Created by Artal Druk on 11/04/2016.
+//  Copyright © 2016 Wix.com All rights reserved.
+//
+
+#import "ObservingInputAccessoryViewTemp.h"
+
+@implementation ObservingInputAccessoryViewTempManager
+
++(ObservingInputAccessoryViewTempManager*)sharedInstance
+{
+    static ObservingInputAccessoryViewTempManager *instance = nil;
+    static dispatch_once_t ObservingInputAccessoryViewTempManagerOnceToken = 0;
+    
+    dispatch_once(&ObservingInputAccessoryViewTempManagerOnceToken,^
+    {
+        if (instance == nil)
+        {
+            instance = [ObservingInputAccessoryViewTempManager new];
+        }
+    });
+    
+    return instance;
+}
+
+@end
+
+@implementation ObservingInputAccessoryViewTemp
+{
+    CGFloat _previousKeyboardHeight;
+}
+
+- (instancetype)init
+{
+    self = [super init];
+    
+    if(self)
+    {
+        self.userInteractionEnabled = NO;
+        self.translatesAutoresizingMaskIntoConstraints = NO;
+        self.autoresizingMask = UIViewAutoresizingFlexibleHeight;
+        
+        [self registerForKeyboardNotifications];
+    }
+    
+    return self;
+}
+
+- (void) registerForKeyboardNotifications
+{
+    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
+    [notificationCenter addObserver:self selector:@selector(_keyboardWillShowNotification:) name:UIKeyboardWillShowNotification object:nil];
+    [notificationCenter addObserver:self selector:@selector(_keyboardDidShowNotification:) name:UIKeyboardDidShowNotification object:nil];
+    [notificationCenter addObserver:self selector:@selector(_keyboardWillHideNotification:) name:UIKeyboardWillHideNotification object:nil];
+    [notificationCenter addObserver:self selector:@selector(_keyboardDidHideNotification:) name:UIKeyboardDidHideNotification object:nil];
+    [notificationCenter addObserver:self selector:@selector(_keyboardWillChangeFrameNotification:) name:UIKeyboardWillChangeFrameNotification object:nil];
+}
+
+- (void)willMoveToSuperview:(UIView *)newSuperview
+{
+    if (self.superview)
+    {
+        [self.superview removeObserver:self forKeyPath:@"center"];
+    }
+    
+    if (newSuperview != nil)
+    {
+        [newSuperview addObserver:self forKeyPath:@"center" options:NSKeyValueObservingOptionNew context:nil];
+    }
+    
+    [super willMoveToSuperview:newSuperview];
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
+{
+    if ((object == self.superview) && ([keyPath isEqualToString:@"center"]))
+    {
+        CGFloat centerY = self.superview.center.y;
+        
+        if([keyPath isEqualToString:@"center"])
+        {
+            centerY = [change[NSKeyValueChangeNewKey] CGPointValue].y;
+        }
+        
+        CGFloat boundsH = self.superview.bounds.size.height;
+        
+        _previousKeyboardHeight = _keyboardHeight;
+        _keyboardHeight = MAX(0, self.window.bounds.size.height - (centerY - boundsH / 2) - self.intrinsicContentSize.height);
+        
+        [_delegate ObservingInputAccessoryViewTempDidChangeFrame:self];
+    }
+}
+
+-(void)dealloc
+{
+    [self.superview removeObserver:self forKeyPath:@"center"];
+    
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (CGSize)intrinsicContentSize
+{
+    return CGSizeMake(self.bounds.size.width, _keyboardState == KeyboardStateWillShow || _keyboardState == KeyboardStateWillHide ? 0 : _height);
+}
+
+- (void)setHeight:(CGFloat)height
+{
+    _height = height;
+    
+    [self invalidateIntrinsicContentSize];
+}
+
+- (void)_keyboardWillShowNotification:(NSNotification*)notification
+{
+    _keyboardState = KeyboardStateWillShow;
+    
+    [self invalidateIntrinsicContentSize];
+    
+    if([_delegate respondsToSelector:@selector(ObservingInputAccessoryViewTempKeyboardWillAppear:keyboardDelta:)])
+    {
+        [_delegate ObservingInputAccessoryViewTempKeyboardWillAppear:self keyboardDelta:_keyboardHeight - _previousKeyboardHeight];
+    }
+}
+
+- (void)_keyboardDidShowNotification:(NSNotification*)notification
+{
+    _keyboardState = KeyboardStateShown;
+    
+    if (_keyboardHeight > 0) { //prevent triggering observeValueForKeyPath if an external keyboard is in use
+        [self invalidateIntrinsicContentSize];
+    }
+}
+
+- (void)_keyboardWillHideNotification:(NSNotification*)notification
+{
+    _keyboardState = KeyboardStateWillHide;
+    
+    [self invalidateIntrinsicContentSize];
+    
+    if([_delegate respondsToSelector:@selector(ObservingInputAccessoryViewTempKeyboardWillDisappear:)])
+    {
+        [_delegate ObservingInputAccessoryViewTempKeyboardWillDisappear:self];
+    }
+}
+
+- (void)_keyboardDidHideNotification:(NSNotification*)notification
+{
+    _keyboardState = KeyboardStateHidden;
+    
+    [self invalidateIntrinsicContentSize];
+}
+
+- (void)_keyboardWillChangeFrameNotification:(NSNotification*)notification
+{
+    if(self.window)
+    {
+        return;
+    }
+    
+    CGRect endFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+    _keyboardHeight = [UIScreen mainScreen].bounds.size.height - endFrame.origin.y;
+    
+    [_delegate ObservingInputAccessoryViewTempDidChangeFrame:self];
+    
+    [self invalidateIntrinsicContentSize];
+}
+
+@end

package/lib/ios/reactnativeuilib/keyboardtrackingview/UIResponder+FirstResponderTemp.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@interface UIResponder (CurrentResponder)
++(id)currentFirstResponder;
+@end

package/lib/ios/reactnativeuilib/keyboardtrackingview/UIResponder+FirstResponderTemp.m

@@ -0,0 +1,17 @@
+#import "UIResponder+FirstResponderTemp.h"
+
+static __weak id currentFirstResponder;
+
+@implementation UIResponder (FirstResponder)
+
++(id)currentFirstResponder {
+    currentFirstResponder = nil;
+    [[UIApplication sharedApplication] sendAction:@selector(findFirstResponder:) to:nil from:nil forEvent:nil];
+    return currentFirstResponder;
+}
+
+-(void)findFirstResponder:(id)sender {
+    currentFirstResponder = self;
+}
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaManager.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+
+@interface SafeAreaManager : RCTEventEmitter
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaManager.m

@@ -0,0 +1,105 @@
+#import "SafeAreaManager.h"
+#import <UIKit/UIKit.h>
+#import <objc/runtime.h>
+
+static NSString *const UIWindowSafeAreaInsetsDidChangeNotification = @"SafeAreaManager.UIWindowSafeAreaInsetsDidChangeNotification";
+static NSString *const SafeAreaInsetsDidChangeEvent = @"SafeAreaInsetsDidChangeEvent";
+static id (*_swz_safeAreaInsetsDidChange_orig)(id self, SEL _cmd);
+
+@interface SafeAreaManager () {
+    UIEdgeInsets _cachedSafeAreaInsets;
+}
+@end
+
+@implementation SafeAreaManager
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[SafeAreaInsetsDidChangeEvent];
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _cachedSafeAreaInsets = [self getCurrentSafeAreaInsets];
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(windowSafeAreaDidChange) name:UIWindowSafeAreaInsetsDidChangeNotification object:nil];
+        [self applySizzles];
+    }
+    return self;
+}
+
+-(void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)windowSafeAreaDidChange {
+    UIEdgeInsets currentSafeAreaInsets = [self getCurrentSafeAreaInsets];
+    if (!UIEdgeInsetsEqualToEdgeInsets(currentSafeAreaInsets, _cachedSafeAreaInsets)) {
+        _cachedSafeAreaInsets = currentSafeAreaInsets;
+        
+        NSUInteger listenerCount = [[self valueForKey:@"_listenerCount"] unsignedIntegerValue];
+        if (listenerCount > 0) {
+            [self sendEventWithName:SafeAreaInsetsDidChangeEvent body:[self getResultDicFromSafeArea:_cachedSafeAreaInsets]];
+        }
+    }
+}
+
+-(UIEdgeInsets)getCurrentSafeAreaInsets {
+    UIEdgeInsets safeAreaInsets = UIEdgeInsetsZero;
+#if __IPHONE_OS_VERSION_MAX_ALLOWED > __IPHONE_10_3
+    if (@available(iOS 11.0, *)) {
+        safeAreaInsets = [UIApplication sharedApplication].keyWindow.safeAreaInsets;
+    }
+#endif
+    return safeAreaInsets;
+}
+
+#pragma mark - swizzles
+
+- (void)applySizzles {
+#if __IPHONE_OS_VERSION_MAX_ALLOWED > __IPHONE_10_3
+    if (@available(iOS 11.0, *)) {
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            Method originalMethod = class_getInstanceMethod([UIWindow class], @selector(safeAreaInsetsDidChange));
+            Method replacementMethod = class_getInstanceMethod([SafeAreaManager class], @selector(_swz_safeAreaInsetsDidChange));
+            _swz_safeAreaInsetsDidChange_orig = (void*)method_getImplementation(originalMethod);
+            method_exchangeImplementations(originalMethod, replacementMethod);
+        });
+    }
+#endif
+}
+
+- (void)_swz_safeAreaInsetsDidChange {
+    _swz_safeAreaInsetsDidChange_orig(self, _cmd);
+    [[NSNotificationCenter defaultCenter] postNotificationName:UIWindowSafeAreaInsetsDidChangeNotification object:nil];
+}
+
+#pragma mark - helper methods
+
+- (NSDictionary*)getResultDicFromSafeArea:(UIEdgeInsets)safeAreaInsets {
+    return @{@"top": @(safeAreaInsets.top),
+             @"left": @(safeAreaInsets.left),
+             @"bottom": @(safeAreaInsets.bottom),
+             @"right": @(safeAreaInsets.right)
+             };
+}
+
+#pragma mark - public API
+
+RCT_EXPORT_METHOD(getSafeAreaInsets:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    UIEdgeInsets safeAreaInsets = [self getCurrentSafeAreaInsets];
+    resolve([self getResultDicFromSafeArea:safeAreaInsets]);
+}
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerShadowView.h

@@ -0,0 +1,5 @@
+#import <React/RCTShadowView.h>
+
+@interface SafeAreaSpacerShadowView : RCTShadowView
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerShadowView.m

@@ -0,0 +1,20 @@
+#import "SafeAreaSpacerShadowView.h"
+#import "SafeAreaSpacerViewLocalData.h"
+
+@implementation SafeAreaSpacerShadowView
+
+- (void)setLocalData:(SafeAreaSpacerViewLocalData *)localData
+{
+    UIEdgeInsets insets = localData.insets;
+    
+    super.height = (YGValue){insets.bottom + insets.top, YGUnitPoint};
+    [self didSetProps:@[@"height"]];
+}
+
+/**
+ * Removing support for setting height from any outside code
+ * to prevent interferring this with local data.
+ */
+- (void)setHeight:(YGValue)height {}
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerView.h

@@ -0,0 +1,7 @@
+#import <React/RCTView.h>
+
+@class RCTBridge;
+
+@interface SafeAreaSpacerView : RCTView
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerView.m

@@ -0,0 +1,76 @@
+#import "SafeAreaSpacerView.h"
+#import "SafeAreaSpacerViewLocalData.h"
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+@implementation SafeAreaSpacerView
+{
+    __weak RCTBridge *_bridge;
+    UIEdgeInsets _currentSafeAreaInsets;
+        //these flags are used to prevent an endless cycle of safe area insets update. setting the view height changes it's frame, and in some cases `reactSetFrame` causes more and more updates with varying sizes
+    BOOL _ignoreNextInsetUpdate;
+    BOOL _insetsWereUpdated;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+    if (self = [super initWithFrame:CGRectZero])
+    {
+        _bridge = bridge;
+        _ignoreNextInsetUpdate = NO;
+        _insetsWereUpdated = NO;
+    }
+    return self;
+}
+
+- (void)reactSetFrame:(CGRect)frame
+{
+    if (self.window != nil && _insetsWereUpdated)
+    {
+        _ignoreNextInsetUpdate = YES;
+        dispatch_async(dispatch_get_main_queue(), ^{
+           _ignoreNextInsetUpdate = NO;
+        });
+    }
+    
+    [super reactSetFrame:frame];
+}
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* __IPHONE_11_0 */
+
+static BOOL UIEdgeInsetsEqualToEdgeInsetsWithThreshold(UIEdgeInsets insets1, UIEdgeInsets insets2, CGFloat threshold)
+{
+    return
+    ABS(insets1.left - insets2.left) <= threshold &&
+    ABS(insets1.right - insets2.right) <= threshold &&
+    ABS(insets1.top - insets2.top) <= threshold &&
+    ABS(insets1.bottom - insets2.bottom) <= threshold;
+}
+
+- (void)safeAreaInsetsDidChange
+{
+    if (![self respondsToSelector:@selector(safeAreaInsets)] || _ignoreNextInsetUpdate)
+    {
+        _ignoreNextInsetUpdate = NO;
+        _insetsWereUpdated = NO;
+        return;
+    }
+    
+    UIEdgeInsets safeAreaInsets = self.safeAreaInsets;
+    
+    if (UIEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale()))
+    {
+        return;
+    }
+    
+    _currentSafeAreaInsets = safeAreaInsets;
+    _insetsWereUpdated = YES;
+    
+    SafeAreaSpacerViewLocalData *localData = [[SafeAreaSpacerViewLocalData alloc] initWithInsets:safeAreaInsets];
+    [_bridge.uiManager setLocalData:localData forView:self];
+}
+
+#endif
+
+@end
+

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerViewLocalData.h

@@ -0,0 +1,9 @@
+#import <UIKit/UIKit.h>
+
+@interface SafeAreaSpacerViewLocalData : NSObject
+
+- (instancetype)initWithInsets:(UIEdgeInsets)insets;
+
+@property (atomic, readonly) UIEdgeInsets insets;
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerViewLocalData.m

@@ -0,0 +1,14 @@
+#import "SafeAreaSpacerViewLocalData.h"
+
+@implementation SafeAreaSpacerViewLocalData
+
+- (instancetype)initWithInsets:(UIEdgeInsets)insets
+{
+    if (self = [super init]) {
+        _insets = insets;
+    }
+    
+    return self;
+}
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerViewManager.h

@@ -0,0 +1,5 @@
+#import <React/RCTViewManager.h>
+
+@interface SafeAreaSpacerViewManager : RCTViewManager
+
+@end

package/lib/ios/reactnativeuilib/safearea/SafeAreaSpacerViewManager.m

@@ -0,0 +1,26 @@
+#import "SafeAreaSpacerViewManager.h"
+
+#import "SafeAreaSpacerShadowView.h"
+#import "SafeAreaSpacerView.h"
+#import <React/RCTUIManager.h>
+
+@implementation SafeAreaSpacerViewManager
+
+RCT_EXPORT_MODULE()
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+
+- (UIView *)view
+{
+    return [[SafeAreaSpacerView alloc] initWithBridge:self.bridge];
+}
+
+- (SafeAreaSpacerShadowView *)shadowView
+{
+    return [SafeAreaSpacerShadowView new];
+}
+
+@end

package/lib/specs/HighlighterViewNativeComponent.ts

@@ -0,0 +1,78 @@
+import type {ViewProps} from 'react-native';
+// import {requireNativeComponent, type ViewProps} from 'react-native';
+import type {Float, Int32, WithDefault} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+export interface HighlightFrame {
+  x: Float;
+  y: Float;
+  width: Float;
+  height: Float;
+}
+
+export interface MinimumRectSize {
+  width: Float;
+  height: Float;
+}
+
+export interface HighlightViewTagParams {
+  paddingLeft?: WithDefault<Float, 0>;
+  paddingTop?: WithDefault<Float, 0>;
+  paddingRight?: WithDefault<Float, 0>;
+  paddingBottom?: WithDefault<Float, 0>;
+  offsetX?: WithDefault<Float, 0>;
+  offsetY?: WithDefault<Float, 0>;
+}
+
+export interface NativeProps extends ViewProps {
+  /**
+   * The frame to highlight with x, y, width, height coordinates
+   */
+  highlightFrame?: HighlightFrame;
+
+  /**
+   * The overlay color (processed color int for Android)
+   */
+  overlayColor?: WithDefault<Int32, 0>;
+
+  /**
+   * The border radius for the highlighted area
+   */
+  borderRadius?: WithDefault<Float, 0>;
+
+  /**
+   * The stroke color (processed color int for Android)
+   */
+  strokeColor?: WithDefault<Int32, 0>;
+
+  /**
+   * The stroke width
+   */
+  strokeWidth?: WithDefault<Float, 0>;
+
+  /**
+   * The React tag of the view to highlight
+   */
+  highlightViewTag?: Int32;
+
+  /**
+   * Parameters for view-based highlighting including padding and offset
+   */
+  highlightViewTagParams?: HighlightViewTagParams;
+
+  /**
+   * Minimum rectangle size for the highlight area
+   */
+  minimumRectSize?: MinimumRectSize;
+
+  /**
+   * Inner padding for the highlight area
+   */
+  innerPadding?: WithDefault<Float, 0>;
+}
+
+export default codegenNativeComponent<NativeProps>('HighlighterView');
+
+// const HighlighterViewNativeComponent = requireNativeComponent<NativeProps>('HighlighterView');
+
+// export default HighlighterViewNativeComponent;

package/lib/specs/KeyboardTrackingViewNativeComponent.ts

@@ -0,0 +1,74 @@
+import type {ViewProps} from 'react-native';
+// import {requireNativeComponent, type ViewProps} from 'react-native';
+import type {Int32, WithDefault} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+export interface NativeProps extends ViewProps {
+  /**
+   * Enables tracking of the keyboard when it's dismissed interactively (false by default).
+   */
+  trackInteractive?: WithDefault<boolean, false>;
+
+  /**
+   * iOS only.
+   * Show the keyboard on a negative scroll
+   */
+  revealKeyboardInteractive?: WithDefault<boolean, false>;
+
+  /**
+   * iOS only.
+   * Set to false to turn off inset management and manage it yourself
+   */
+  manageScrollView?: WithDefault<boolean, true>;
+
+  /**
+   * iOS only.
+   * Set to true manageScrollView is set to true and still does not work
+   */
+  requiresSameParentToManageScrollView?: WithDefault<boolean, false>;
+
+  /**
+   * iOS only.
+   * Allow hitting sub-views that are placed beyond the view bounds
+   */
+  allowHitsOutsideBounds?: WithDefault<boolean, false>;
+
+  /**
+   * Should the scrollView scroll to the focused input
+   */
+  scrollToFocusedInput?: WithDefault<boolean, false>;
+
+  /**
+   * iOS only.
+   * The scrolling behavior (NONE | SCROLL_TO_BOTTOM_INVERTED_ONLY | FIXED_OFFSET)
+   */
+  scrollBehavior?: WithDefault<Int32, 0>;
+
+  /**
+   * iOS only.
+   * Add a SafeArea view beneath the KeyboardAccessoryView
+   */
+  addBottomView?: WithDefault<boolean, false>;
+
+  /**
+   * iOS only.
+   * The bottom view's color
+   */
+  bottomViewColor?: string;
+
+  /**
+   * Allow control safe area
+   */
+  useSafeArea?: WithDefault<boolean, false>;
+
+  /**
+   * Whether or not to include bottom tab bar inset
+   */
+  usesBottomTabs?: WithDefault<boolean, false>;
+}
+
+export default codegenNativeComponent<NativeProps>('KeyboardTrackingViewTemp');
+
+// const KeyboardTrackingViewNativeComponent = requireNativeComponent<NativeProps>('KeyboardTrackingViewTemp');
+
+// export default KeyboardTrackingViewNativeComponent;