@depup/react-native 0.84.1-depup.2

package/React/Modules/RCTRedBoxExtraDataViewController.m

@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTRedBoxExtraDataViewController.h"
+#import "React/RCTUtils.h"
+
+@interface RCTRedBoxExtraDataCell : UITableViewCell
+
+@property (nonatomic, strong) UILabel *keyLabel;
+@property (nonatomic, strong) UILabel *valueLabel;
+
+@end
+
+@implementation RCTRedBoxExtraDataCell
+
+- (instancetype)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier
+{
+  if (self = [super initWithStyle:style reuseIdentifier:reuseIdentifier]) {
+    self.backgroundColor = [UIColor colorWithRed:0.8 green:0 blue:0 alpha:1];
+    UILayoutGuide *contentLayout = self.contentView.layoutMarginsGuide;
+
+    self.keyLabel = [UILabel new];
+    [self.contentView addSubview:self.keyLabel];
+    self.keyLabel.translatesAutoresizingMaskIntoConstraints = NO;
+    [NSLayoutConstraint activateConstraints:@[
+      [self.keyLabel.leadingAnchor constraintEqualToAnchor:contentLayout.leadingAnchor],
+      [self.keyLabel.topAnchor constraintEqualToAnchor:contentLayout.topAnchor],
+      [self.keyLabel.bottomAnchor constraintEqualToAnchor:contentLayout.bottomAnchor],
+      [self.keyLabel.widthAnchor constraintEqualToAnchor:contentLayout.widthAnchor multiplier:0.3]
+    ]];
+    self.keyLabel.textColor = [UIColor whiteColor];
+    self.keyLabel.numberOfLines = 0;
+    self.keyLabel.lineBreakMode = NSLineBreakByWordWrapping;
+    self.keyLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:12.0f];
+
+    self.valueLabel = [UILabel new];
+    [self.contentView addSubview:self.valueLabel];
+    self.valueLabel.translatesAutoresizingMaskIntoConstraints = NO;
+    [NSLayoutConstraint activateConstraints:@[
+      [self.valueLabel.leadingAnchor constraintEqualToAnchor:self.keyLabel.trailingAnchor constant:10.f],
+      [self.valueLabel.trailingAnchor constraintEqualToAnchor:contentLayout.trailingAnchor],
+      [self.valueLabel.topAnchor constraintEqualToAnchor:contentLayout.topAnchor],
+      [self.valueLabel.bottomAnchor constraintEqualToAnchor:contentLayout.bottomAnchor]
+    ]];
+    self.valueLabel.textColor = [UIColor whiteColor];
+    self.valueLabel.numberOfLines = 0;
+    self.valueLabel.lineBreakMode = NSLineBreakByWordWrapping;
+    self.valueLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:12.0f];
+  }
+  return self;
+}
+
+@end
+
+@interface RCTRedBoxExtraDataViewController ()
+
+@end
+
+@implementation RCTRedBoxExtraDataViewController {
+  UITableView *_tableView;
+  NSMutableArray *_extraDataTitle;
+  NSMutableArray *_extraData;
+}
+
+@synthesize actionDelegate = _actionDelegate;
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _extraData = [NSMutableArray new];
+    _extraDataTitle = [NSMutableArray new];
+  }
+  return self;
+}
+
+- (UIButton *)redBoxButtonWithTitle:(NSString *)title
+            accessibilityIdentifier:(NSString *)accessibilityIdentifier
+                             action:(SEL)action
+{
+  UIButton *button = [UIButton buttonWithType:UIButtonTypeCustom];
+  button.accessibilityIdentifier = accessibilityIdentifier;
+
+  button.backgroundColor = [UIColor colorWithRed:0.1 green:0.1 blue:0.1 alpha:1];
+
+  button.titleLabel.font = [UIFont systemFontOfSize:13];
+
+  [button setTitle:title forState:UIControlStateNormal];
+  [button setTitleColor:[UIColor colorWithWhite:1 alpha:1] forState:UIControlStateNormal];
+  [button setTitleColor:[UIColor colorWithWhite:1 alpha:0.5] forState:UIControlStateHighlighted];
+
+  [button addTarget:self action:action forControlEvents:UIControlEventTouchUpInside];
+  return button;
+}
+
+- (void)viewDidLoad
+{
+  CGFloat bottomSafeAreaInset = RCTKeyWindow().safeAreaInsets.bottom;
+
+  CGFloat buttonHeight = 60;
+  CGFloat buttonWidth = self.view.bounds.size.width / 2;
+
+  _tableView = [UITableView new];
+  _tableView.translatesAutoresizingMaskIntoConstraints = NO;
+  _tableView.delegate = self;
+  _tableView.dataSource = self;
+  _tableView.backgroundColor = [UIColor colorWithRed:0.8 green:0 blue:0 alpha:1];
+  _tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
+  _tableView.indicatorStyle = UIScrollViewIndicatorStyleWhite;
+  _tableView.allowsSelection = NO;
+  [self.view addSubview:_tableView];
+
+#if TARGET_OS_SIMULATOR || TARGET_OS_MACCATALYST
+  NSString *reloadText = @"Reload JS (\u2318R)";
+  NSString *dismissText = @"Dismiss (ESC)";
+#else
+  NSString *reloadText = @"Reload JS";
+  NSString *dismissText = @"Dismiss";
+#endif
+
+  UIButton *dismissButton = [self redBoxButtonWithTitle:dismissText
+                                accessibilityIdentifier:@"redbox-extra-data-dismiss"
+                                                 action:@selector(dismiss)];
+  UIButton *reloadButton = [self redBoxButtonWithTitle:reloadText
+                               accessibilityIdentifier:@"redbox-reload"
+                                                action:@selector(reload)];
+
+  UIStackView *buttonStackView = [[UIStackView alloc] init];
+  buttonStackView.translatesAutoresizingMaskIntoConstraints = NO;
+  buttonStackView.axis = UILayoutConstraintAxisHorizontal;
+  buttonStackView.distribution = UIStackViewDistributionFillEqually;
+  buttonStackView.alignment = UIStackViewAlignmentTop;
+  buttonStackView.backgroundColor = [UIColor colorWithRed:0.1 green:0.1 blue:0.1 alpha:1];
+
+  [buttonStackView addArrangedSubview:dismissButton];
+  [buttonStackView addArrangedSubview:reloadButton];
+
+  [self.view addSubview:buttonStackView];
+
+  [NSLayoutConstraint activateConstraints:@[
+    [_tableView.topAnchor constraintEqualToAnchor:self.view.topAnchor],
+    [_tableView.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
+    [_tableView.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
+    [_tableView.bottomAnchor constraintEqualToAnchor:buttonStackView.topAnchor],
+
+    [dismissButton.heightAnchor constraintEqualToConstant:buttonHeight],
+    [dismissButton.widthAnchor constraintEqualToConstant:buttonWidth],
+    [reloadButton.heightAnchor constraintEqualToConstant:buttonHeight],
+    [reloadButton.widthAnchor constraintEqualToConstant:buttonWidth],
+    [buttonStackView.heightAnchor constraintEqualToConstant:buttonHeight + bottomSafeAreaInset],
+
+    [buttonStackView.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
+    [buttonStackView.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
+    [buttonStackView.bottomAnchor constraintEqualToAnchor:self.view.bottomAnchor],
+  ]];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+  [super viewDidAppear:animated];
+  [_tableView reloadData];
+}
+
+- (NSInteger)tableView:(__unused UITableView *)tableView numberOfRowsInSection:(NSInteger)section
+{
+  return [[_extraData objectAtIndex:section] count];
+}
+
+- (CGFloat)tableView:(__unused UITableView *)tableView heightForHeaderInSection:(__unused NSInteger)section
+{
+  return 40;
+}
+
+- (UIView *)tableView:(__unused UITableView *)tableView viewForHeaderInSection:(NSInteger)section
+{
+  UIView *header = [UIView new];
+  header.backgroundColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
+
+  UILabel *headerLabel = [UILabel new];
+  [header addSubview:headerLabel];
+
+  headerLabel.translatesAutoresizingMaskIntoConstraints = NO;
+  [NSLayoutConstraint activateConstraints:@[
+    [headerLabel.leadingAnchor constraintEqualToAnchor:header.leadingAnchor constant:5],
+    [headerLabel.trailingAnchor constraintEqualToAnchor:header.trailingAnchor],
+    [headerLabel.topAnchor constraintEqualToAnchor:header.topAnchor],
+    [headerLabel.bottomAnchor constraintEqualToAnchor:header.bottomAnchor],
+  ]];
+
+  headerLabel.textColor = [UIColor whiteColor];
+  headerLabel.font = [UIFont fontWithName:@"Menlo-Bold" size:14.0f];
+  headerLabel.text = [_extraDataTitle[section] uppercaseString];
+
+  return header;
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  static NSString *reuseIdentifier = @"RedBoxExtraData";
+
+  RCTRedBoxExtraDataCell *cell =
+      (RCTRedBoxExtraDataCell *)[tableView dequeueReusableCellWithIdentifier:reuseIdentifier];
+
+  if (cell == nil) {
+    cell = [[RCTRedBoxExtraDataCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:reuseIdentifier];
+  }
+
+  NSArray *dataKVPair = _extraData[indexPath.section][indexPath.row];
+  cell.keyLabel.text = dataKVPair[0];
+  cell.valueLabel.text = dataKVPair[1];
+
+  return cell;
+}
+
+- (NSInteger)numberOfSectionsInTableView:(__unused UITableView *)tableView
+{
+  return _extraDataTitle.count;
+}
+
+- (void)addExtraData:(NSDictionary *)data forIdentifier:(NSString *)identifier
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSMutableArray *newData = [NSMutableArray new];
+    for (id key in data) {
+      [newData addObject:@[
+        [NSString stringWithFormat:@"%@", key],
+        [NSString stringWithFormat:@"%@", [data objectForKey:key]]
+      ]];
+    }
+
+    NSInteger idx = [self->_extraDataTitle indexOfObject:identifier];
+    if (idx == NSNotFound) {
+      [self->_extraDataTitle addObject:identifier];
+      [self->_extraData addObject:newData];
+    } else {
+      [self->_extraData replaceObjectAtIndex:idx withObject:newData];
+    }
+
+    [self->_tableView reloadData];
+  });
+}
+
+- (void)dismiss
+{
+  [self dismissViewControllerAnimated:YES completion:nil];
+}
+
+- (void)reload
+{
+  [_actionDelegate reload];
+}
+
+#pragma mark - Key commands
+
+- (NSArray<UIKeyCommand *> *)keyCommands
+{
+  return @[
+    // Dismiss
+    [UIKeyCommand keyCommandWithInput:UIKeyInputEscape modifierFlags:0 action:@selector(dismiss)],
+    // Reload
+    [UIKeyCommand keyCommandWithInput:@"r" modifierFlags:UIKeyModifierCommand action:@selector(reload)]
+  ];
+}
+
+@end

package/React/Modules/RCTSurfacePresenterStub.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <objc/runtime.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeProxy.h>
+
+@protocol RCTSurfaceProtocol;
+
+NS_ASSUME_NONNULL_BEGIN
+
+// TODO: Eventually this should go away and files should just include RCTSurfacePresenter.h, but
+// that pulls in all of fabric which doesn't compile in open source yet, so we mirror the protocol
+// and duplicate the category here for now.
+
+@protocol RCTSurfacePresenterObserver <NSObject>
+
+@optional
+
+- (void)willMountComponentsWithRootTag:(NSInteger)rootTag;
+- (void)didMountComponentsWithRootTag:(NSInteger)rootTag;
+
+@end
+
+@protocol RCTSurfacePresenterStub <NSObject>
+
+- (id<RCTSurfaceProtocol>)createFabricSurfaceForModuleName:(NSString *)moduleName
+                                         initialProperties:(NSDictionary *)initialProperties;
+- (nullable UIView *)findComponentViewWithTag_DO_NOT_USE_DEPRECATED:(NSInteger)tag;
+- (void)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag props:(NSDictionary *)props;
+- (void)addObserver:(id<RCTSurfacePresenterObserver>)observer;
+- (void)removeObserver:(id<RCTSurfacePresenterObserver>)observer;
+
+@end
+
+@interface RCTBridge (RCTSurfacePresenterStub)
+
+- (id<RCTSurfacePresenterStub>)surfacePresenter;
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)presenter;
+
+@end
+
+@interface RCTBridgeProxy (RCTSurfacePresenterStub)
+
+- (id<RCTSurfacePresenterStub>)surfacePresenter;
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)presenter;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/React/Modules/RCTSurfacePresenterStub.m

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTSurfacePresenterStub.h"
+
+@implementation RCTBridge (RCTSurfacePresenterStub)
+
+- (id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  return objc_getAssociatedObject(self, @selector(surfacePresenter));
+}
+
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  objc_setAssociatedObject(self, @selector(surfacePresenter), surfacePresenter, OBJC_ASSOCIATION_RETAIN);
+}
+
+@end
+
+@implementation RCTBridgeProxy (RCTSurfacePresenterStub)
+
+- (id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  return objc_getAssociatedObject(self, @selector(surfacePresenter));
+}
+
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  objc_setAssociatedObject(self, @selector(surfacePresenter), surfacePresenter, OBJC_ASSOCIATION_RETAIN);
+}
+
+@end

package/React/Modules/RCTUIManager.h

@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTBridgeProxy.h>
+#import <React/RCTInvalidating.h>
+#import <React/RCTRootView.h>
+#import <React/RCTViewManager.h>
+
+/**
+ * Posted right before re-render happens. This is a chance for views to invalidate their state so
+ * next render cycle will pick up updated views and layout appropriately.
+ */
+RCT_EXTERN NSString *const RCTUIManagerWillUpdateViewsDueToContentSizeMultiplierChangeNotification;
+
+@class RCTLayoutAnimationGroup;
+@class RCTUIManagerObserverCoordinator;
+
+/**
+ * The RCTUIManager is the module responsible for updating the view hierarchy.
+ */
+@interface RCTUIManager : NSObject <RCTBridgeModule, RCTInvalidating>
+
+/**
+ * Register a root view tag and creates corresponding `rootView` and
+ * `rootShadowView`.
+ */
+- (void)registerRootViewTag:(NSNumber *)rootTag;
+
+/**
+ * Register a root view with the RCTUIManager.
+ */
+- (void)registerRootView:(UIView *)rootView;
+
+/**
+ * Gets the view name associated with a reactTag.
+ */
+- (NSString *)viewNameForReactTag:(NSNumber *)reactTag;
+
+/**
+ * Gets the view associated with a reactTag.
+ */
+- (UIView *)viewForReactTag:(NSNumber *)reactTag;
+
+/**
+ * Gets the shadow view associated with a reactTag.
+ */
+- (RCTShadowView *)shadowViewForReactTag:(NSNumber *)reactTag;
+
+/**
+ * Set the available size (`availableSize` property) for a root view.
+ * This might be used in response to changes in external layout constraints.
+ * This value will be directly trasmitted to layout engine and defines how big viewport is;
+ * this value does not affect root node size style properties.
+ * Can be considered as something similar to `setSize:forView:` but applicable only for root view.
+ */
+- (void)setAvailableSize:(CGSize)availableSize forRootView:(UIView *)rootView;
+
+/**
+ * Sets local data for a shadow view corresponded with given view.
+ * In some cases we need a way to specify some environmental data to shadow view
+ * to improve layout (or do something similar), so `localData` serves these needs.
+ * For example, any stateful embedded native views may benefit from this.
+ * Have in mind that this data is not supposed to interfere with the state of
+ * the shadow view.
+ * Please respect one-directional data flow of React.
+ */
+- (void)setLocalData:(NSObject *)localData forView:(UIView *)view;
+
+/**
+ * Set the size of a view. This might be in response to a screen rotation
+ * or some other layout event outside of the React-managed view hierarchy.
+ */
+- (void)setSize:(CGSize)size forView:(UIView *)view;
+
+/**
+ * Set the natural size of a view, which is used when no explicit size is set.
+ * Use `UIViewNoIntrinsicMetric` to ignore a dimension.
+ * The `size` must NOT include padding and border.
+ */
+- (void)setIntrinsicContentSize:(CGSize)intrinsicContentSize forView:(UIView *)view;
+
+/**
+ * Sets up layout animation which will perform on next layout pass.
+ * The animation will affect only one next layout pass.
+ * Must be called on the main queue.
+ */
+- (void)setNextLayoutAnimationGroup:(RCTLayoutAnimationGroup *)layoutAnimationGroup;
+
+/**
+ * Schedule a block to be executed on the UI thread. Useful if you need to execute
+ * view logic after all currently queued view updates have completed.
+ */
+- (void)addUIBlock:(RCTViewManagerUIBlock)block;
+
+/**
+ * Schedule a block to be executed on the UI thread. Useful if you need to execute
+ * view logic before all currently queued view updates have completed.
+ */
+- (void)prependUIBlock:(RCTViewManagerUIBlock)block;
+
+/**
+ * Used by native animated module to bypass the process of updating the values through the shadow
+ * view hierarchy. This method will directly update native views, which means that updates for
+ * layout-related propertied won't be handled properly.
+ * Make sure you know what you're doing before calling this method :)
+ */
+- (void)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag
+                                 viewName:(NSString *)viewName
+                                    props:(NSDictionary *)props;
+
+/**
+ * Given a reactTag from a component, find its root view, if possible.
+ * Otherwise, this will give back nil.
+ *
+ * @param reactTag the component tag
+ * @param completion the completion block that will hand over the rootView, if any.
+ *
+ */
+- (void)rootViewForReactTag:(NSNumber *)reactTag withCompletion:(void (^)(UIView *view))completion;
+
+/**
+ * Finds a view that is tagged with nativeID as its nativeID prop
+ * with the associated rootTag root tag view hierarchy. Returns the
+ * view if found, nil otherwise.
+ *
+ * @param nativeID the id reference to native component relative to root view.
+ * @param rootTag the react tag of root view hierarchy from which to find the view.
+ */
+- (UIView *)viewForNativeID:(NSString *)nativeID withRootTag:(NSNumber *)rootTag;
+
+/**
+ * Register a view that is tagged with nativeID as its nativeID prop
+ *
+ * @param nativeID the id reference to native component relative to root view.
+ * @param view the view that is tagged with nativeID as its nativeID prop.
+ */
+- (void)setNativeID:(NSString *)nativeID forView:(UIView *)view;
+
+/**
+ * The view that is currently first responder, according to the JS context.
+ */
++ (UIView *)JSResponder;
+
+/**
+ * In some cases we might want to trigger layout from native side.
+ * React won't be aware of this, so we need to make sure it happens.
+ */
+- (void)setNeedsLayout;
+
+/**
+ * Dedicated object for subscribing for UIManager events.
+ * See `RCTUIManagerObserver` protocol for more details.
+ */
+@property (atomic, retain, readonly) RCTUIManagerObserverCoordinator *observerCoordinator;
+
+@end
+
+/**
+ * This category makes the current RCTUIManager instance available via the
+ * RCTBridge, which is useful for RCTBridgeModules or RCTViewManagers that
+ * need to access the RCTUIManager.
+ */
+@interface RCTBridge (RCTUIManager)
+
+@property (nonatomic, readonly) RCTUIManager *uiManager;
+
+@end
+
+@interface RCTBridgeProxy (RCTUIManager)
+
+@property (nonatomic, readonly) RCTUIManager *uiManager;
+
+@end
+
+/**
+ * This is a composed ViewRegistry which implement the same behavior of a Dictionary.
+ * We need this because, when libraries use `addUIBlock` they receives both the UIManager and a Dictionary which maps
+ * reactTags to Views. The problem is that in the New Architecture that dictionary is always empty and many libraries
+ * broke because they want to access the dictionary. Instead, they should use the `uiManager viewForReactTag` method to
+ * retrieve the views they need.
+ *
+ * The `RCTComposedViewRegistry` follows the composite pattern and receives as inputs the `RCTUIManager`and the
+ * dictionary that was passed to the libraries. It extends `NSDictionary` to make sure that it has the same interface of
+ * the parameter that is passed. This class fixes the problem because we override the`objectForKeyedSubscript:` method
+ * which is used to access the dictionary. That method is now implemented looking in the dictionary registry first and
+ * then using the`viewForReactTag` method.
+ */
+@interface RCTComposedViewRegistry : NSMutableDictionary
+
+- (instancetype)initWithUIManager:(RCTUIManager *)uiManager andRegistry:(NSDictionary<NSNumber *, UIView *> *)registry;
+
+@end
+
+// This protocol is needed to silence the "unknown selector" warning
+@protocol RCTRendererInteropLayerAdapting
+- (UIView *)paperView;
+@end
+
+/**
+ * This method is used to extract the wrapped view
+ * from a view that might be the Interop Layer view wrapper.
+ * If the view passed as parameter is the Interop Layer wrapper, this method returns the wrapped view
+ * Otherwise, it returns the view itself.
+ */
+RCT_EXTERN UIView *RCTPaperViewOrCurrentView(UIView *view);
+
+RCT_EXTERN NSMutableDictionary<NSString *, id> *RCTModuleConstantsForDestructuredComponent(
+    NSMutableDictionary<NSString *, NSDictionary *> *directEvents,
+    NSMutableDictionary<NSString *, NSDictionary *> *bubblingEvents,
+    Class managerClass,
+    NSString *name,
+    NSDictionary<NSString *, id> *viewConfig);