feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ActivityIndicator/RCTActivityIndicatorViewComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for root <ActivityIndicator> component.
+ */
+@interface RCTActivityIndicatorViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ActivityIndicator/RCTActivityIndicatorViewComponentView.mm

@@ -0,0 +1,99 @@
+/*
+ * 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 "RCTActivityIndicatorViewComponentView.h"
+
+#import <React/RCTConversions.h>
+
+#import <react/renderer/components/rncore/ComponentDescriptors.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+static UIActivityIndicatorViewStyle convertActivityIndicatorViewStyle(const ActivityIndicatorViewSize &size)
+{
+  switch (size) {
+    case ActivityIndicatorViewSize::Small:
+      return UIActivityIndicatorViewStyleMedium;
+    case ActivityIndicatorViewSize::Large:
+      return UIActivityIndicatorViewStyleLarge;
+  }
+}
+
+@implementation RCTActivityIndicatorViewComponentView {
+  UIActivityIndicatorView *_activityIndicatorView;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<ActivityIndicatorViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    const auto &defaultProps = ActivityIndicatorViewShadowNode::defaultSharedProps();
+    _props = defaultProps;
+
+    _activityIndicatorView = [[UIActivityIndicatorView alloc] initWithFrame:self.bounds];
+    _activityIndicatorView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+
+    if (defaultProps->animating) {
+      [_activityIndicatorView startAnimating];
+    } else {
+      [_activityIndicatorView stopAnimating];
+    }
+    _activityIndicatorView.color = RCTUIColorFromSharedColor(defaultProps->color);
+    _activityIndicatorView.hidesWhenStopped = defaultProps->hidesWhenStopped;
+    _activityIndicatorView.activityIndicatorViewStyle = convertActivityIndicatorViewStyle(defaultProps->size);
+
+    [self addSubview:_activityIndicatorView];
+  }
+
+  return self;
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps = static_cast<const ActivityIndicatorViewProps &>(*_props);
+  const auto &newViewProps = static_cast<const ActivityIndicatorViewProps &>(*props);
+
+  if (oldViewProps.animating != newViewProps.animating) {
+    if (newViewProps.animating) {
+      [_activityIndicatorView startAnimating];
+    } else {
+      [_activityIndicatorView stopAnimating];
+    }
+  }
+
+  if (oldViewProps.color != newViewProps.color) {
+    _activityIndicatorView.color = RCTUIColorFromSharedColor(newViewProps.color);
+  }
+
+  // TODO: This prop should be deprecated.
+  if (oldViewProps.hidesWhenStopped != newViewProps.hidesWhenStopped) {
+    _activityIndicatorView.hidesWhenStopped = newViewProps.hidesWhenStopped;
+  }
+
+  if (oldViewProps.size != newViewProps.size) {
+    _activityIndicatorView.activityIndicatorViewStyle = convertActivityIndicatorViewStyle(newViewProps.size);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTActivityIndicatorViewCls(void)
+{
+  return RCTActivityIndicatorViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/DebuggingOverlay/RCTDebuggingOverlayComponentView.h

@@ -0,0 +1,16 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+#import <react/renderer/components/rncore/RCTComponentViewHelpers.h>
+
+@interface RCTDebuggingOverlayComponentView : RCTViewComponentView <RCTDebuggingOverlayViewProtocol>
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/DebuggingOverlay/RCTDebuggingOverlayComponentView.mm

@@ -0,0 +1,73 @@
+/*
+ * 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 "RCTDebuggingOverlayComponentView.h"
+
+#import <React/RCTDebuggingOverlay.h>
+#import <React/RCTDefines.h>
+#import <React/RCTLog.h>
+
+#import <react/renderer/components/rncore/ComponentDescriptors.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+#import <react/renderer/components/rncore/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@implementation RCTDebuggingOverlayComponentView {
+  RCTDebuggingOverlay *_overlay;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = DebuggingOverlayShadowNode::defaultSharedProps();
+    _overlay = [[RCTDebuggingOverlay alloc] initWithFrame:self.bounds];
+
+    self.contentView = _overlay;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<DebuggingOverlayComponentDescriptor>();
+}
+
+#pragma mark - Native commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTDebuggingOverlayHandleCommand(self, commandName, args);
+}
+
+- (void)highlightTraceUpdates:(NSArray *)updates
+{
+  [_overlay highlightTraceUpdates:updates];
+}
+
+- (void)highlightElements:(NSArray *)elements
+{
+  [_overlay highlightElements:elements];
+}
+
+- (void)clearElementsHighlights
+{
+  [_overlay clearElementsHighlights];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTDebuggingOverlayCls(void)
+{
+  return RCTDebuggingOverlayComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Image/RCTImageComponentView.h

@@ -0,0 +1,24 @@
+/*
+ * 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 <React/RCTImageResponseDelegate.h>
+#import <React/RCTUIImageViewAnimated.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for root <Image> component.
+ */
+@interface RCTImageComponentView : RCTViewComponentView <RCTImageResponseDelegate> {
+ @protected
+  RCTUIImageViewAnimated *_imageView;
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Image/RCTImageComponentView.mm

@@ -0,0 +1,208 @@
+/*
+ * 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 "RCTImageComponentView.h"
+
+#import <React/RCTAssert.h>
+#import <React/RCTConversions.h>
+#import <React/RCTImageBlurUtils.h>
+#import <React/RCTImageResponseObserverProxy.h>
+#import <react/renderer/components/image/ImageComponentDescriptor.h>
+#import <react/renderer/components/image/ImageEventEmitter.h>
+#import <react/renderer/components/image/ImageProps.h>
+#import <react/renderer/imagemanager/ImageRequest.h>
+#import <react/renderer/imagemanager/RCTImagePrimitivesConversions.h>
+#import <react/utils/CoreFeatures.h>
+
+using namespace facebook::react;
+
+@implementation RCTImageComponentView {
+  ImageShadowNode::ConcreteState::Shared _state;
+  RCTImageResponseObserverProxy _imageResponseObserverProxy;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    const auto &defaultProps = ImageShadowNode::defaultSharedProps();
+    _props = defaultProps;
+
+    _imageView = [RCTUIImageViewAnimated new];
+    _imageView.clipsToBounds = YES;
+    _imageView.contentMode = RCTContentModeFromImageResizeMode(defaultProps->resizeMode);
+    _imageView.layer.minificationFilter = kCAFilterTrilinear;
+    _imageView.layer.magnificationFilter = kCAFilterTrilinear;
+
+    _imageResponseObserverProxy = RCTImageResponseObserverProxy(self);
+
+    self.contentView = _imageView;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<ImageComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldImageProps = static_cast<const ImageProps &>(*_props);
+  const auto &newImageProps = static_cast<const ImageProps &>(*props);
+
+  // `resizeMode`
+  if (oldImageProps.resizeMode != newImageProps.resizeMode) {
+    _imageView.contentMode = RCTContentModeFromImageResizeMode(newImageProps.resizeMode);
+  }
+
+  // `tintColor`
+  if (oldImageProps.tintColor != newImageProps.tintColor) {
+    _imageView.tintColor = RCTUIColorFromSharedColor(newImageProps.tintColor);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  RCTAssert(state, @"`state` must not be null.");
+  RCTAssert(
+      std::dynamic_pointer_cast<ImageShadowNode::ConcreteState const>(state),
+      @"`state` must be a pointer to `ImageShadowNode::ConcreteState`.");
+
+  auto oldImageState = std::static_pointer_cast<ImageShadowNode::ConcreteState const>(_state);
+  auto newImageState = std::static_pointer_cast<ImageShadowNode::ConcreteState const>(state);
+
+  [self _setStateAndResubscribeImageResponseObserver:newImageState];
+
+  bool havePreviousData = oldImageState && oldImageState->getData().getImageSource() != ImageSource{};
+
+  if (!havePreviousData ||
+      (newImageState && newImageState->getData().getImageSource() != oldImageState->getData().getImageSource())) {
+    // Loading actually starts a little before this, but this is the first time we know
+    // the image is loading and can fire an event from this component
+    static_cast<const ImageEventEmitter &>(*_eventEmitter).onLoadStart();
+
+    // TODO (T58941612): Tracking for visibility should be done directly on this class.
+    // For now, we consolidate instrumentation logic in the image loader, so that pre-Fabric gets the same treatment.
+  }
+}
+
+- (void)_setStateAndResubscribeImageResponseObserver:(const ImageShadowNode::ConcreteState::Shared &)state
+{
+  if (_state) {
+    const auto &imageRequest = _state->getData().getImageRequest();
+    auto &observerCoordinator = imageRequest.getObserverCoordinator();
+    observerCoordinator.removeObserver(_imageResponseObserverProxy);
+    // Cancelling image request because we are no longer observing it.
+    // This is not 100% correct place to do this because we may want to
+    // re-create RCTImageComponentView with the same image and if it
+    // was cancelled before downloaded, download is not resumed.
+    // This will only become issue if we decouple life cycle of a
+    // ShadowNode from ComponentView, which is not something we do now.
+    imageRequest.cancel();
+  }
+
+  _state = state;
+
+  if (_state) {
+    auto &observerCoordinator = _state->getData().getImageRequest().getObserverCoordinator();
+    observerCoordinator.addObserver(_imageResponseObserverProxy);
+  }
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  [self _setStateAndResubscribeImageResponseObserver:nullptr];
+  _imageView.image = nil;
+}
+
+#pragma mark - RCTImageResponseDelegate
+
+- (void)didReceiveImage:(UIImage *)image metadata:(id)metadata fromObserver:(const void *)observer
+{
+  if (!_eventEmitter || !_state) {
+    // Notifications are delivered asynchronously and might arrive after the view is already recycled.
+    // In the future, we should incorporate an `EventEmitter` into a separate object owned by `ImageRequest` or `State`.
+    // See for more info: T46311063.
+    return;
+  }
+
+  static_cast<const ImageEventEmitter &>(*_eventEmitter).onLoad();
+  static_cast<const ImageEventEmitter &>(*_eventEmitter).onLoadEnd();
+
+  const auto &imageProps = static_cast<const ImageProps &>(*_props);
+
+  if (imageProps.tintColor) {
+    image = [image imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
+  }
+
+  if (imageProps.resizeMode == ImageResizeMode::Repeat) {
+    image = [image resizableImageWithCapInsets:RCTUIEdgeInsetsFromEdgeInsets(imageProps.capInsets)
+                                  resizingMode:UIImageResizingModeTile];
+  } else if (imageProps.capInsets != EdgeInsets()) {
+    // Applying capInsets of 0 will switch the "resizingMode" of the image to "tile" which is undesired.
+    image = [image resizableImageWithCapInsets:RCTUIEdgeInsetsFromEdgeInsets(imageProps.capInsets)
+                                  resizingMode:UIImageResizingModeStretch];
+  }
+
+  if (imageProps.blurRadius > __FLT_EPSILON__) {
+    // Blur on a background thread to avoid blocking interaction.
+    CGFloat blurRadius = imageProps.blurRadius;
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+      UIImage *blurredImage = RCTBlurredImageWithRadius(image, blurRadius);
+      RCTExecuteOnMainQueue(^{
+        self->_imageView.image = blurredImage;
+      });
+    });
+  } else {
+    self->_imageView.image = image;
+  }
+}
+
+- (void)didReceiveProgress:(float)progress fromObserver:(const void *)observer
+{
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ImageEventEmitter &>(*_eventEmitter).onProgress(progress);
+}
+
+- (void)didReceiveFailureFromObserver:(const void *)observer
+{
+  _imageView.image = nil;
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ImageEventEmitter &>(*_eventEmitter).onError();
+  static_cast<const ImageEventEmitter &>(*_eventEmitter).onLoadEnd();
+}
+
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Can't the import generated Plugin.h because plugins are not in this BUCK target
+Class<RCTComponentViewProtocol> RCTImageCls(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+Class<RCTComponentViewProtocol> RCTImageCls(void)
+{
+  return RCTImageComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/InputAccessory/RCTInputAccessoryComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for root <InputAccessoryView> component.
+ */
+@interface RCTInputAccessoryComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/InputAccessory/RCTInputAccessoryComponentView.mm

@@ -0,0 +1,153 @@
+/*
+ * 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 "RCTInputAccessoryComponentView.h"
+
+#import <React/RCTBackedTextInputViewProtocol.h>
+#import <React/RCTConversions.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <React/RCTUtils.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/inputaccessory/InputAccessoryComponentDescriptor.h>
+#import <react/renderer/components/rncore/Props.h>
+#import "RCTInputAccessoryContentView.h"
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+static UIView<RCTBackedTextInputViewProtocol> *_Nullable RCTFindTextInputWithNativeId(UIView *view, NSString *nativeId)
+{
+  if ([view respondsToSelector:@selector(inputAccessoryViewID)] &&
+      [view respondsToSelector:@selector(setInputAccessoryView:)]) {
+    UIView<RCTBackedTextInputViewProtocol> *typed = (UIView<RCTBackedTextInputViewProtocol> *)view;
+    if (!nativeId || [typed.inputAccessoryViewID isEqualToString:nativeId]) {
+      return typed;
+    }
+  }
+
+  for (UIView *subview in view.subviews) {
+    UIView<RCTBackedTextInputViewProtocol> *result = RCTFindTextInputWithNativeId(subview, nativeId);
+    if (result) {
+      return result;
+    }
+  }
+
+  return nil;
+}
+
+@implementation RCTInputAccessoryComponentView {
+  InputAccessoryShadowNode::ConcreteState::Shared _state;
+  RCTInputAccessoryContentView *_contentView;
+  RCTSurfaceTouchHandler *_touchHandler;
+  UIView<RCTBackedTextInputViewProtocol> __weak *_textInput;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = InputAccessoryShadowNode::defaultSharedProps();
+    _contentView = [RCTInputAccessoryContentView new];
+    _touchHandler = [RCTSurfaceTouchHandler new];
+    [_touchHandler attachToView:_contentView];
+  }
+
+  return self;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (self.window && !_textInput) {
+    if (self.nativeId) {
+      _textInput = RCTFindTextInputWithNativeId(self.window, self.nativeId);
+      _textInput.inputAccessoryView = _contentView;
+    } else {
+      _textInput = RCTFindTextInputWithNativeId(_contentView, nil);
+    }
+
+    if (!self.nativeId) {
+      [self becomeFirstResponder];
+    }
+  }
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return true;
+}
+
+- (UIView *)inputAccessoryView
+{
+  return _contentView;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<InputAccessoryComponentDescriptor>();
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_contentView insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldInputAccessoryProps = static_cast<const InputAccessoryProps &>(*_props);
+  const auto &newInputAccessoryProps = static_cast<const InputAccessoryProps &>(*props);
+
+  if (newInputAccessoryProps.backgroundColor != oldInputAccessoryProps.backgroundColor) {
+    _contentView.backgroundColor = RCTUIColorFromSharedColor(newInputAccessoryProps.backgroundColor);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+  self.hidden = true;
+}
+
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<InputAccessoryShadowNode::ConcreteState const>(state);
+  CGSize oldScreenSize = RCTCGSizeFromSize(_state->getData().viewportSize);
+  CGSize viewportSize = RCTViewportSize();
+  viewportSize.height = std::nan("");
+  if (oldScreenSize.width != viewportSize.width) {
+    auto stateData = InputAccessoryState{RCTSizeFromCGSize(viewportSize)};
+    _state->updateState(std::move(stateData));
+  }
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+
+  [_contentView setFrame:RCTCGRectFromRect(layoutMetrics.getContentFrame())];
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _state.reset();
+  _textInput = nil;
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTInputAccessoryCls(void)
+{
+  return RCTInputAccessoryComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/InputAccessory/RCTInputAccessoryContentView.h

@@ -0,0 +1,12 @@
+/*
+ * 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>
+
+@interface RCTInputAccessoryContentView : UIView
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/InputAccessory/RCTInputAccessoryContentView.mm

@@ -0,0 +1,61 @@
+/*
+ * 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 "RCTInputAccessoryContentView.h"
+
+@implementation RCTInputAccessoryContentView {
+  UIView *_safeAreaContainer;
+  NSLayoutConstraint *_heightConstraint;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.autoresizingMask = UIViewAutoresizingFlexibleHeight;
+
+    _safeAreaContainer = [UIView new];
+    _safeAreaContainer.translatesAutoresizingMaskIntoConstraints = NO;
+    [self addSubview:_safeAreaContainer];
+
+    _heightConstraint = [_safeAreaContainer.heightAnchor constraintEqualToConstant:0];
+    _heightConstraint.active = YES;
+
+    [NSLayoutConstraint activateConstraints:@[
+      [_safeAreaContainer.bottomAnchor constraintEqualToAnchor:self.safeAreaLayoutGuide.bottomAnchor],
+      [_safeAreaContainer.topAnchor constraintEqualToAnchor:self.safeAreaLayoutGuide.topAnchor],
+      [_safeAreaContainer.leadingAnchor constraintEqualToAnchor:self.safeAreaLayoutGuide.leadingAnchor],
+      [_safeAreaContainer.trailingAnchor constraintEqualToAnchor:self.safeAreaLayoutGuide.trailingAnchor]
+    ]];
+  }
+  return self;
+}
+
+- (CGSize)intrinsicContentSize
+{
+  // This is needed so the view size is based on autolayout constraints.
+  return CGSizeZero;
+}
+
+- (void)insertSubview:(UIView *)view atIndex:(NSInteger)index
+{
+  [_safeAreaContainer insertSubview:view atIndex:index];
+}
+
+- (void)setFrame:(CGRect)frame
+{
+  [super setFrame:frame];
+  [_safeAreaContainer setFrame:frame];
+  _heightConstraint.constant = frame.size.height;
+  [self layoutIfNeeded];
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return true;
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/LegacyViewManagerInterop/RCTLegacyViewManagerInteropComponentView.h

@@ -0,0 +1,32 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTLegacyViewManagerInteropComponentView : RCTViewComponentView
+
+/**
+ Returns true for components that are supported by LegacyViewManagerInterop layer, false otherwise.
+ */
++ (BOOL)isSupported:(NSString *)componentName;
+
++ (void)supportLegacyViewManagerWithName:(NSString *)componentName;
++ (void)supportLegacyViewManagersWithPrefix:(NSString *)prefix;
+
+/**
+ * This method is required for addUIBlock and to let the infra bypass the interop layer
+ * when providing views from the RCTUIManager. The interop layer should be transparent to the users.
+ */
+- (UIView *)paperView;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/LegacyViewManagerInterop/RCTLegacyViewManagerInteropComponentView.mm

@@ -0,0 +1,278 @@
+/*
+ * 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 "RCTLegacyViewManagerInteropComponentView.h"
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTConstants.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropComponentDescriptor.h>
+#import <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropViewProps.h>
+#import <react/utils/ManagedObjectWrapper.h>
+#import "RCTLegacyViewManagerInteropCoordinatorAdapter.h"
+
+using namespace facebook::react;
+
+static NSString *const kRCTLegacyInteropChildComponentKey = @"childComponentView";
+static NSString *const kRCTLegacyInteropChildIndexKey = @"index";
+
+@implementation RCTLegacyViewManagerInteropComponentView {
+  NSMutableArray<NSDictionary *> *_viewsToBeMounted;
+  NSMutableArray<UIView *> *_viewsToBeUnmounted;
+  RCTLegacyViewManagerInteropCoordinatorAdapter *_adapter;
+  LegacyViewManagerInteropShadowNode::ConcreteState::Shared _state;
+  BOOL _hasInvokedForwardingWarning;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = LegacyViewManagerInteropShadowNode::defaultSharedProps();
+    _viewsToBeMounted = [NSMutableArray new];
+    _viewsToBeUnmounted = [NSMutableArray new];
+    _hasInvokedForwardingWarning = NO;
+  }
+
+  return self;
+}
+
+- (RCTLegacyViewManagerInteropCoordinator *)_coordinator
+{
+  if (_state != nullptr) {
+    const auto &state = _state->getData();
+    return unwrapManagedObject(state.coordinator);
+  } else {
+    return nil;
+  }
+}
+
+- (NSString *)componentViewName_DO_NOT_USE_THIS_IS_BROKEN
+{
+  const auto &state = _state->getData();
+  RCTLegacyViewManagerInteropCoordinator *coordinator = unwrapManagedObject(state.coordinator);
+  return coordinator.componentViewName;
+}
+
+#pragma mark - Method forwarding
+
+- (void)forwardInvocation:(NSInvocation *)anInvocation
+{
+  if (!_hasInvokedForwardingWarning) {
+    _hasInvokedForwardingWarning = YES;
+    NSLog(
+        @"Invoked unsupported method on RCTLegacyViewManagerInteropComponentView. Resulting to noop instead of a crash.");
+  }
+}
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
+{
+  return [super methodSignatureForSelector:aSelector] ?: [self.contentView methodSignatureForSelector:aSelector];
+}
+
+#pragma mark - Supported ViewManagers
+
++ (NSMutableSet<NSString *> *)supportedViewManagers
+{
+  static NSMutableSet<NSString *> *supported = [NSMutableSet setWithObjects:@"DatePicker",
+                                                                            @"ProgressView",
+                                                                            @"SegmentedControl",
+                                                                            @"MaskedView",
+                                                                            @"ARTSurfaceView",
+                                                                            @"ARTText",
+                                                                            @"ARTShape",
+                                                                            @"ARTGroup",
+                                                                            nil];
+  return supported;
+}
+
++ (NSMutableSet<NSString *> *)supportedViewManagersPrefixes
+{
+  static NSMutableSet<NSString *> *supported = [NSMutableSet new];
+  return supported;
+}
+
++ (NSMutableDictionary<NSString *, Class> *)_supportedLegacyViewComponents
+{
+  static NSMutableDictionary<NSString *, Class> *suppoerted = [NSMutableDictionary new];
+  return suppoerted;
+}
+
++ (BOOL)isSupported:(NSString *)componentName
+{
+  // Step 1: check if ViewManager with specified name is supported.
+  BOOL isComponentNameSupported =
+      [[RCTLegacyViewManagerInteropComponentView supportedViewManagers] containsObject:componentName];
+  if (isComponentNameSupported) {
+    return YES;
+  }
+
+  // Step 2: check if component has supported prefix.
+  for (NSString *item in [RCTLegacyViewManagerInteropComponentView supportedViewManagersPrefixes]) {
+    if ([componentName hasPrefix:item]) {
+      return YES;
+    }
+  }
+
+  // Step 3: check if the module has been registered
+  // TODO(T174674274): Implement lazy loading of legacy view managers in the new architecture.
+  NSArray<Class> *registeredModules = RCTGetModuleClasses();
+  NSMutableDictionary<NSString *, Class> *supportedLegacyViewComponents =
+      [RCTLegacyViewManagerInteropComponentView _supportedLegacyViewComponents];
+  if (supportedLegacyViewComponents[componentName] != NULL) {
+    return YES;
+  }
+
+  for (Class moduleClass in registeredModules) {
+    id<RCTBridgeModule> bridgeModule = (id<RCTBridgeModule>)moduleClass;
+    NSString *moduleName = [[bridgeModule moduleName] isEqualToString:@""]
+        ? [NSStringFromClass(moduleClass) stringByReplacingOccurrencesOfString:@"Manager" withString:@""]
+        : [bridgeModule moduleName];
+
+    if (supportedLegacyViewComponents[moduleName] == NULL) {
+      supportedLegacyViewComponents[moduleName] = moduleClass;
+    }
+
+    if ([moduleName isEqualToString:componentName] ||
+        [moduleName isEqualToString:[@"RCT" stringByAppendingString:componentName]]) {
+      return YES;
+    }
+  }
+
+  return NO;
+}
+
++ (void)supportLegacyViewManagersWithPrefix:(NSString *)prefix
+{
+  [[RCTLegacyViewManagerInteropComponentView supportedViewManagersPrefixes] addObject:prefix];
+}
+
++ (void)supportLegacyViewManagerWithName:(NSString *)componentName
+{
+  [[RCTLegacyViewManagerInteropComponentView supportedViewManagers] addObject:componentName];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)prepareForRecycle
+{
+  _adapter = nil;
+  [_viewsToBeMounted removeAllObjects];
+  [_viewsToBeUnmounted removeAllObjects];
+  _state.reset();
+  self.contentView = nil;
+  _hasInvokedForwardingWarning = NO;
+  [super prepareForRecycle];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_viewsToBeMounted addObject:@{
+    kRCTLegacyInteropChildIndexKey : [NSNumber numberWithInteger:index],
+    kRCTLegacyInteropChildComponentKey : childComponentView
+  }];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  if (_adapter) {
+    [_adapter.paperView removeReactSubview:childComponentView];
+  } else {
+    [_viewsToBeUnmounted addObject:childComponentView];
+  }
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<LegacyViewManagerInteropComponentDescriptor>();
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<LegacyViewManagerInteropShadowNode::ConcreteState const>(state);
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
+{
+  [super finalizeUpdates:updateMask];
+  __block BOOL propsUpdated = NO;
+
+  __weak __typeof(self) weakSelf = self;
+  void (^updatePropsIfNeeded)(RNComponentViewUpdateMask) = ^void(RNComponentViewUpdateMask mask) {
+    __typeof(self) strongSelf = weakSelf;
+    if (!propsUpdated) {
+      [strongSelf _setPropsWithUpdateMask:mask];
+      propsUpdated = YES;
+    }
+  };
+
+  if (!_adapter) {
+    _adapter = [[RCTLegacyViewManagerInteropCoordinatorAdapter alloc] initWithCoordinator:[self _coordinator]
+                                                                                 reactTag:self.tag];
+    _adapter.eventInterceptor = ^(std::string eventName, folly::dynamic event) {
+      if (weakSelf) {
+        __typeof(self) strongSelf = weakSelf;
+        const auto &eventEmitter =
+            static_cast<LegacyViewManagerInteropViewEventEmitter const &>(*strongSelf->_eventEmitter);
+        eventEmitter.dispatchEvent(eventName, event);
+      }
+    };
+    // Set props immediately. This is required to set the initial state of the view.
+    // In the case where some events are fired in relationship of a change in the frame
+    // or layout of the view, they will fire as soon as the contentView is set and if the
+    // event block is nil, the app will crash.
+    updatePropsIfNeeded(updateMask);
+    propsUpdated = YES;
+
+    self.contentView = _adapter.paperView;
+  }
+
+  for (NSDictionary *mountInstruction in _viewsToBeMounted) {
+    NSNumber *index = mountInstruction[kRCTLegacyInteropChildIndexKey];
+    UIView *childView = mountInstruction[kRCTLegacyInteropChildComponentKey];
+    if ([childView isKindOfClass:[RCTLegacyViewManagerInteropComponentView class]]) {
+      UIView *target = ((RCTLegacyViewManagerInteropComponentView *)childView).contentView;
+      [_adapter.paperView insertReactSubview:target atIndex:index.integerValue];
+    } else {
+      [_adapter.paperView insertReactSubview:childView atIndex:index.integerValue];
+    }
+  }
+
+  [_viewsToBeMounted removeAllObjects];
+
+  for (UIView *view in _viewsToBeUnmounted) {
+    [_adapter.paperView removeReactSubview:view];
+  }
+
+  [_viewsToBeUnmounted removeAllObjects];
+
+  [_adapter.paperView didUpdateReactSubviews];
+
+  updatePropsIfNeeded(updateMask);
+}
+
+- (void)_setPropsWithUpdateMask:(RNComponentViewUpdateMask)updateMask
+{
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    const auto &newProps = static_cast<const LegacyViewManagerInteropViewProps &>(*_props);
+    [_adapter setProps:newProps.otherProps];
+  }
+}
+
+- (UIView *)paperView
+{
+  return _adapter.paperView;
+}
+
+#pragma mark - Native Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  [_adapter handleCommand:(NSString *)commandName args:(NSArray *)args];
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/LegacyViewManagerInterop/RCTLegacyViewManagerInteropCoordinatorAdapter.h

@@ -0,0 +1,27 @@
+/*
+ * 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 <Foundation/Foundation.h>
+#import <react/renderer/components/legacyviewmanagerinterop/RCTLegacyViewManagerInteropCoordinator.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTLegacyViewManagerInteropCoordinatorAdapter : NSObject
+
+- (instancetype)initWithCoordinator:(RCTLegacyViewManagerInteropCoordinator *)coordinator reactTag:(NSInteger)tag;
+
+@property (strong, nonatomic) UIView *paperView;
+
+@property (nonatomic, copy, nullable) void (^eventInterceptor)(std::string eventName, folly::dynamic event);
+
+- (void)setProps:(const folly::dynamic &)props;
+
+- (void)handleCommand:(NSString *)commandName args:(NSArray *)args;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/LegacyViewManagerInterop/RCTLegacyViewManagerInteropCoordinatorAdapter.mm

@@ -0,0 +1,148 @@
+/*
+ * 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 "RCTLegacyViewManagerInteropCoordinatorAdapter.h"
+#import <React/RCTFollyConvert.h>
+#import <React/UIView+React.h>
+
+@implementation RCTLegacyViewManagerInteropCoordinatorAdapter {
+  RCTLegacyViewManagerInteropCoordinator *_coordinator;
+  NSInteger _tag;
+  NSDictionary<NSString *, id> *_oldProps;
+}
+
+- (instancetype)initWithCoordinator:(RCTLegacyViewManagerInteropCoordinator *)coordinator reactTag:(NSInteger)tag
+{
+  if (self = [super init]) {
+    _coordinator = coordinator;
+    _tag = tag;
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  [_paperView removeFromSuperview];
+  [_coordinator removeObserveForTag:_tag];
+}
+
+- (UIView *)paperView
+{
+  if (!_paperView) {
+    _paperView = [_coordinator createPaperViewWithTag:_tag];
+    __weak __typeof(self) weakSelf = self;
+    [_coordinator addObserveForTag:_tag
+                        usingBlock:^(std::string eventName, folly::dynamic event) {
+                          if (weakSelf.eventInterceptor) {
+                            weakSelf.eventInterceptor(eventName, event);
+                          }
+                        }];
+  }
+  return _paperView;
+}
+
+- (void)setProps:(const folly::dynamic &)props
+{
+  if (props.isObject()) {
+    NSDictionary<NSString *, id> *convertedProps = facebook::react::convertFollyDynamicToId(props);
+    NSDictionary<NSString *, id> *diffedProps = [self _diffProps:convertedProps];
+
+    [_coordinator setProps:diffedProps forView:self.paperView];
+
+    _oldProps = convertedProps;
+  }
+}
+
+- (void)handleCommand:(NSString *)commandName args:(NSArray *)args
+{
+  [_coordinator handleCommand:commandName args:args reactTag:_tag paperView:self.paperView];
+}
+
+- (NSDictionary<NSString *, id> *)_diffProps:(NSDictionary<NSString *, id> *)newProps
+{
+  NSMutableDictionary<NSString *, id> *diffedProps = [NSMutableDictionary new];
+
+  [newProps enumerateKeysAndObjectsUsingBlock:^(NSString *key, id newProp, __unused BOOL *stop) {
+    id oldProp = _oldProps[key];
+    if ([self _prop:newProp isDifferentFrom:oldProp]) {
+      diffedProps[key] = newProp;
+    }
+  }];
+
+  return diffedProps;
+}
+
+#pragma mark - Private
+
+- (BOOL)_prop:(id)oldProp isDifferentFrom:(id)newProp
+{
+  // Check for JSON types.
+  // JSON types can be of:
+  // * number
+  // * bool
+  // * String
+  // * Array
+  // * Objects => Dictionaries in ObjectiveC
+  // * Null
+
+  // Check for NULL
+  BOOL bothNil = !oldProp && !newProp;
+  if (bothNil) {
+    return NO;
+  }
+
+  BOOL onlyOneNil = (oldProp && !newProp) || (!oldProp && newProp);
+  if (onlyOneNil) {
+    return YES;
+  }
+
+  if ([self _propIsSameNumber:oldProp second:newProp]) {
+    // Boolean should be captured by NSNumber
+    return NO;
+  }
+
+  if ([self _propIsSameString:oldProp second:newProp]) {
+    return NO;
+  }
+
+  if ([self _propIsSameArray:oldProp second:newProp]) {
+    return NO;
+  }
+
+  if ([self _propIsSameObject:oldProp second:newProp]) {
+    return NO;
+  }
+
+  // Previous behavior, fallback to YES
+  return YES;
+}
+
+- (BOOL)_propIsSameNumber:(id)first second:(id)second
+{
+  return [first isKindOfClass:[NSNumber class]] && [second isKindOfClass:[NSNumber class]] &&
+      [(NSNumber *)first isEqualToNumber:(NSNumber *)second];
+}
+
+- (BOOL)_propIsSameString:(id)first second:(id)second
+{
+  return [first isKindOfClass:[NSString class]] && [second isKindOfClass:[NSString class]] &&
+      [(NSString *)first isEqualToString:(NSString *)second];
+}
+
+- (BOOL)_propIsSameArray:(id)first second:(id)second
+{
+  return [first isKindOfClass:[NSArray class]] && [second isKindOfClass:[NSArray class]] &&
+      [(NSArray *)first isEqualToArray:(NSArray *)second];
+}
+
+- (BOOL)_propIsSameObject:(id)first second:(id)second
+{
+  return [first isKindOfClass:[NSDictionary class]] && [second isKindOfClass:[NSDictionary class]] &&
+      [(NSDictionary *)first isEqualToDictionary:(NSDictionary *)second];
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Modal/RCTFabricModalHostViewController.h

@@ -0,0 +1,20 @@
+/*
+ * 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>
+
+@protocol RCTFabricModalHostViewControllerDelegate <NSObject>
+- (void)boundsDidChange:(CGRect)newBounds;
+@end
+
+@interface RCTFabricModalHostViewController : UIViewController
+
+@property (nonatomic, weak) id<RCTFabricModalHostViewControllerDelegate> delegate;
+
+@property (nonatomic, assign) UIInterfaceOrientationMask supportedInterfaceOrientations;
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Modal/RCTFabricModalHostViewController.mm

@@ -0,0 +1,80 @@
+/*
+ * 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 "RCTFabricModalHostViewController.h"
+
+#import <React/RCTLog.h>
+#import <React/RCTSurfaceTouchHandler.h>
+
+@implementation RCTFabricModalHostViewController {
+  CGRect _lastViewBounds;
+  RCTSurfaceTouchHandler *_touchHandler;
+}
+
+- (instancetype)init
+{
+  if (!(self = [super init])) {
+    return nil;
+  }
+  _touchHandler = [RCTSurfaceTouchHandler new];
+
+  self.modalInPresentation = YES;
+
+  return self;
+}
+
+- (void)viewDidLayoutSubviews
+{
+  [super viewDidLayoutSubviews];
+  if (!CGRectEqualToRect(_lastViewBounds, self.view.bounds)) {
+    [_delegate boundsDidChange:self.view.bounds];
+    _lastViewBounds = self.view.bounds;
+  }
+}
+
+- (void)loadView
+{
+  [super loadView];
+  [_touchHandler attachToView:self.view];
+}
+
+- (UIStatusBarStyle)preferredStatusBarStyle
+{
+  return [RCTUIStatusBarManager() statusBarStyle];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [super viewDidDisappear:animated];
+  _lastViewBounds = CGRectZero;
+}
+
+- (BOOL)prefersStatusBarHidden
+{
+  return [RCTUIStatusBarManager() isStatusBarHidden];
+}
+
+#if RCT_DEV
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations
+{
+  UIInterfaceOrientationMask appSupportedOrientationsMask =
+      [RCTSharedApplication() supportedInterfaceOrientationsForWindow:[RCTSharedApplication() keyWindow]];
+  if (!(_supportedInterfaceOrientations & appSupportedOrientationsMask)) {
+    RCTLogError(
+        @"Modal was presented with 0x%x orientations mask but the application only supports 0x%x."
+        @"Add more interface orientations to your app's Info.plist to fix this."
+        @"NOTE: This will crash in non-dev mode.",
+        (unsigned)_supportedInterfaceOrientations,
+        (unsigned)appSupportedOrientationsMask);
+    return UIInterfaceOrientationMaskAll;
+  }
+
+  return _supportedInterfaceOrientations;
+}
+#endif // RCT_DEV
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Modal/RCTModalHostViewComponentView.h

@@ -0,0 +1,32 @@
+/*
+ * 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 <React/RCTMountingTransactionObserving.h>
+#import <React/RCTViewComponentView.h>
+
+/**
+ * UIView class for root <ModalHostView> component.
+ */
+@interface RCTModalHostViewComponentView : RCTViewComponentView <RCTMountingTransactionObserving>
+
+/**
+ * Subclasses may override this method and present the modal on different view controller.
+ * Default implementation presents the modal on `[self reactViewController]`.
+ */
+- (void)presentViewController:(UIViewController *)modalViewController
+                     animated:(BOOL)animated
+                   completion:(void (^)(void))completion;
+
+/**
+ * Subclasses may override this method.
+ * Default implementation calls `[UIViewController dismissViewControllerAnimated:completion:]`.
+ */
+- (void)dismissViewController:(UIViewController *)modalViewController
+                     animated:(BOOL)animated
+                   completion:(void (^)(void))completion;
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Modal/RCTModalHostViewComponentView.mm

@@ -0,0 +1,300 @@
+/*
+ * 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 "RCTModalHostViewComponentView.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTModalManager.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/modal/ModalHostViewComponentDescriptor.h>
+#import <react/renderer/components/modal/ModalHostViewState.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+
+#import "RCTConversions.h"
+
+#import "RCTFabricModalHostViewController.h"
+
+using namespace facebook::react;
+
+static UIInterfaceOrientationMask supportedOrientationsMask(ModalHostViewSupportedOrientationsMask mask)
+{
+  UIInterfaceOrientationMask supportedOrientations = 0;
+
+  if (mask & ModalHostViewSupportedOrientations::Portrait) {
+    supportedOrientations |= UIInterfaceOrientationMaskPortrait;
+  }
+
+  if (mask & ModalHostViewSupportedOrientations::PortraitUpsideDown) {
+    supportedOrientations |= UIInterfaceOrientationMaskPortraitUpsideDown;
+  }
+
+  if (mask & ModalHostViewSupportedOrientations::Landscape) {
+    supportedOrientations |= UIInterfaceOrientationMaskLandscape;
+  }
+
+  if (mask & ModalHostViewSupportedOrientations::LandscapeLeft) {
+    supportedOrientations |= UIInterfaceOrientationMaskLandscapeLeft;
+  }
+
+  if (mask & ModalHostViewSupportedOrientations::LandscapeRight) {
+    supportedOrientations |= UIInterfaceOrientationMaskLandscapeRight;
+  }
+
+  if (supportedOrientations == 0) {
+    if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPad) {
+      return UIInterfaceOrientationMaskAll;
+    } else {
+      return UIInterfaceOrientationMaskPortrait;
+    }
+  }
+
+  return supportedOrientations;
+}
+
+static std::tuple<BOOL, UIModalTransitionStyle> animationConfiguration(const ModalHostViewAnimationType animation)
+{
+  switch (animation) {
+    case ModalHostViewAnimationType::None:
+      return std::make_tuple(NO, UIModalTransitionStyleCoverVertical);
+    case ModalHostViewAnimationType::Slide:
+      return std::make_tuple(YES, UIModalTransitionStyleCoverVertical);
+    case ModalHostViewAnimationType::Fade:
+      return std::make_tuple(YES, UIModalTransitionStyleCrossDissolve);
+  }
+}
+
+static UIModalPresentationStyle presentationConfiguration(const ModalHostViewProps &props)
+{
+  if (props.transparent) {
+    return UIModalPresentationOverFullScreen;
+  }
+  switch (props.presentationStyle) {
+    case ModalHostViewPresentationStyle::FullScreen:
+      return UIModalPresentationFullScreen;
+    case ModalHostViewPresentationStyle::PageSheet:
+      return UIModalPresentationPageSheet;
+    case ModalHostViewPresentationStyle::FormSheet:
+      return UIModalPresentationFormSheet;
+    case ModalHostViewPresentationStyle::OverFullScreen:
+      return UIModalPresentationOverFullScreen;
+  }
+}
+
+static ModalHostViewEventEmitter::OnOrientationChange onOrientationChangeStruct(CGRect rect)
+{
+  ;
+  auto orientation = rect.size.width < rect.size.height
+      ? ModalHostViewEventEmitter::OnOrientationChangeOrientation::Portrait
+      : ModalHostViewEventEmitter::OnOrientationChangeOrientation::Landscape;
+  return {orientation};
+}
+
+@interface RCTModalHostViewComponentView () <RCTFabricModalHostViewControllerDelegate>
+
+@end
+
+@implementation RCTModalHostViewComponentView {
+  RCTFabricModalHostViewController *_viewController;
+  ModalHostViewShadowNode::ConcreteState::Shared _state;
+  BOOL _shouldAnimatePresentation;
+  BOOL _shouldPresent;
+  BOOL _isPresented;
+  UIView *_modalContentsSnapshot;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = ModalHostViewShadowNode::defaultSharedProps();
+    _shouldAnimatePresentation = YES;
+
+    _isPresented = NO;
+  }
+
+  return self;
+}
+
+- (RCTFabricModalHostViewController *)viewController
+{
+  if (!_viewController) {
+    _viewController = [RCTFabricModalHostViewController new];
+    _viewController.modalTransitionStyle = UIModalTransitionStyleCoverVertical;
+    _viewController.delegate = self;
+  }
+  return _viewController;
+}
+
+- (void)presentViewController:(UIViewController *)modalViewController
+                     animated:(BOOL)animated
+                   completion:(void (^)(void))completion
+{
+  UIViewController *controller = [self reactViewController];
+  [controller presentViewController:modalViewController animated:animated completion:completion];
+}
+
+- (void)dismissViewController:(UIViewController *)modalViewController
+                     animated:(BOOL)animated
+                   completion:(void (^)(void))completion
+{
+  [modalViewController dismissViewControllerAnimated:animated completion:completion];
+}
+
+- (void)ensurePresentedOnlyIfNeeded
+{
+  BOOL shouldBePresented = !_isPresented && _shouldPresent && self.window;
+  if (shouldBePresented) {
+    _isPresented = YES;
+    [self presentViewController:self.viewController
+                       animated:_shouldAnimatePresentation
+                     completion:^{
+                       auto eventEmitter = [self modalEventEmitter];
+                       if (eventEmitter) {
+                         eventEmitter->onShow(ModalHostViewEventEmitter::OnShow{});
+                       }
+                     }];
+  }
+
+  BOOL shouldBeHidden = _isPresented && (!_shouldPresent || !self.superview);
+  if (shouldBeHidden) {
+    _isPresented = NO;
+    // To animate dismissal of view controller, snapshot of
+    // view hierarchy needs to be added to the UIViewController.
+    UIView *snapshot = _modalContentsSnapshot;
+
+    if (_shouldPresent) {
+      [self.viewController.view addSubview:snapshot];
+    }
+
+    [self dismissViewController:self.viewController
+                       animated:_shouldAnimatePresentation
+                     completion:^{
+                       [snapshot removeFromSuperview];
+                       auto eventEmitter = [self modalEventEmitter];
+                       if (eventEmitter) {
+                         eventEmitter->onDismiss(ModalHostViewEventEmitter::OnDismiss{});
+                       }
+                     }];
+  }
+}
+
+- (std::shared_ptr<const ModalHostViewEventEmitter>)modalEventEmitter
+{
+  if (!_eventEmitter) {
+    return nullptr;
+  }
+
+  assert(std::dynamic_pointer_cast<const ModalHostViewEventEmitter>(_eventEmitter));
+  return std::static_pointer_cast<const ModalHostViewEventEmitter>(_eventEmitter);
+}
+
+#pragma mark - RCTMountingTransactionObserving
+
+- (void)mountingTransactionWillMount:(const MountingTransaction &)transaction
+                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  _modalContentsSnapshot = [self.viewController.view snapshotViewAfterScreenUpdates:YES];
+}
+
+#pragma mark - UIView methods
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  [self ensurePresentedOnlyIfNeeded];
+}
+
+- (void)didMoveToSuperview
+{
+  [super didMoveToSuperview];
+  [self ensurePresentedOnlyIfNeeded];
+}
+
+#pragma mark - RCTFabricModalHostViewControllerDelegate
+
+- (void)boundsDidChange:(CGRect)newBounds
+{
+  auto eventEmitter = [self modalEventEmitter];
+  if (eventEmitter) {
+    eventEmitter->onOrientationChange(onOrientationChangeStruct(newBounds));
+  }
+
+  if (_state != nullptr) {
+    auto newState = ModalHostViewState{RCTSizeFromCGSize(newBounds.size)};
+    _state->updateState(std::move(newState));
+  }
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<ModalHostViewComponentDescriptor>();
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _state.reset();
+  _viewController = nil;
+  _isPresented = NO;
+  _shouldPresent = NO;
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newProps = static_cast<const ModalHostViewProps &>(*props);
+
+#if !TARGET_OS_TV
+  self.viewController.supportedInterfaceOrientations = supportedOrientationsMask(newProps.supportedOrientations);
+#endif
+
+  const auto [shouldAnimate, transitionStyle] = animationConfiguration(newProps.animationType);
+  _shouldAnimatePresentation = shouldAnimate;
+  self.viewController.modalTransitionStyle = transitionStyle;
+
+  self.viewController.modalPresentationStyle = presentationConfiguration(newProps);
+
+  _shouldPresent = newProps.visible;
+  [self ensurePresentedOnlyIfNeeded];
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<const ModalHostViewShadowNode::ConcreteState>(state);
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [self.viewController.view insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Can't the import generated Plugin.h because plugins are not in this BUCK target
+Class<RCTComponentViewProtocol> RCTModalHostViewCls(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+Class<RCTComponentViewProtocol> RCTModalHostViewCls(void)
+{
+  return RCTModalHostViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/RCTFabricComponentsPlugins.h

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// FB Internal: FBRCTFabricComponentsPlugins.h is autogenerated by the build system.
+#import <React/FBRCTFabricComponentsPlugins.h>
+
+#else
+
+// OSS-compatibility layer
+
+#import <Foundation/Foundation.h>
+#import <React/RCTThirdPartyFabricComponentsProvider.h>
+#import <React/RCTComponentViewProtocol.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Class<RCTComponentViewProtocol> RCTFabricComponentsProvider(const char *name);
+
+// Lookup functions
+Class<RCTComponentViewProtocol> RCTActivityIndicatorViewCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTDebuggingOverlayCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTInputAccessoryCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTParagraphCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTPullToRefreshViewCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTSafeAreaViewCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTScrollViewCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTSwitchCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTTextInputCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTUnimplementedNativeViewCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTViewCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTImageCls(void) __attribute__((used));
+Class<RCTComponentViewProtocol> RCTModalHostViewCls(void) __attribute__((used));
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/RCTFabricComponentsPlugins.mm

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifndef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// OSS-compatibility layer
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <string>
+#import <unordered_map>
+
+Class<RCTComponentViewProtocol> RCTFabricComponentsProvider(const char *name) {
+  static std::unordered_map<std::string, Class (*)(void)> sFabricComponentsClassMap = {
+    {"ActivityIndicatorView", RCTActivityIndicatorViewCls},
+    {"DebuggingOverlay", RCTDebuggingOverlayCls},
+    {"InputAccessoryView", RCTInputAccessoryCls},
+    {"Paragraph", RCTParagraphCls},
+    {"PullToRefreshView", RCTPullToRefreshViewCls},
+    {"SafeAreaView", RCTSafeAreaViewCls},
+    {"ScrollView", RCTScrollViewCls},
+    {"Switch", RCTSwitchCls},
+    {"TextInput", RCTTextInputCls},
+    {"UnimplementedNativeView", RCTUnimplementedNativeViewCls},
+    {"View", RCTViewCls},
+    {"Image", RCTImageCls},
+    {"ModalHostView", RCTModalHostViewCls},
+  };
+
+  auto p = sFabricComponentsClassMap.find(name);
+  if (p != sFabricComponentsClassMap.end()) {
+    auto classFunc = p->second;
+    return classFunc();
+  }
+  return RCTThirdPartyFabricComponentsProvider(name);
+}
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Root/RCTRootComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for root <View> component.
+ */
+@interface RCTRootComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Root/RCTRootComponentView.mm

@@ -0,0 +1,34 @@
+/*
+ * 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 "RCTRootComponentView.h"
+
+#import <react/renderer/components/root/RootComponentDescriptor.h>
+#import <react/renderer/components/root/RootProps.h>
+#import "RCTConversions.h"
+
+using namespace facebook::react;
+
+@implementation RCTRootComponentView
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = RootShadowNode::defaultSharedProps();
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RootComponentDescriptor>();
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/SafeAreaView/RCTSafeAreaViewComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for root <SafeAreaView> component.
+ */
+@interface RCTSafeAreaViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/SafeAreaView/RCTSafeAreaViewComponentView.mm

@@ -0,0 +1,100 @@
+/*
+ * 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 "RCTSafeAreaViewComponentView.h"
+
+#import <React/RCTUtils.h>
+#import <react/renderer/components/safeareaview/SafeAreaViewComponentDescriptor.h>
+#import <react/renderer/components/safeareaview/SafeAreaViewState.h>
+#import "RCTConversions.h"
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@implementation RCTSafeAreaViewComponentView {
+  SafeAreaViewShadowNode::ConcreteState::Shared _state;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = SafeAreaViewShadowNode::defaultSharedProps();
+  }
+
+  return self;
+}
+
+- (void)safeAreaInsetsDidChange
+{
+  [super safeAreaInsetsDidChange];
+
+  [self _updateStateIfNecessary];
+}
+
+- (void)_updateStateIfNecessary
+{
+  if (!_state) {
+    return;
+  }
+
+  UIEdgeInsets insets = self.safeAreaInsets;
+  insets.left = RCTRoundPixelValue(insets.left);
+  insets.top = RCTRoundPixelValue(insets.top);
+  insets.right = RCTRoundPixelValue(insets.right);
+  insets.bottom = RCTRoundPixelValue(insets.bottom);
+
+  auto newPadding = RCTEdgeInsetsFromUIEdgeInsets(insets);
+  auto threshold = 1.0 / RCTScreenScale() + 0.01; // Size of a pixel plus some small threshold.
+
+  _state->updateState(
+      [=](const SafeAreaViewShadowNode::ConcreteState::Data &oldData)
+          -> SafeAreaViewShadowNode::ConcreteState::SharedData {
+        auto oldPadding = oldData.padding;
+        auto deltaPadding = newPadding - oldPadding;
+
+        if (std::abs(deltaPadding.left) < threshold && std::abs(deltaPadding.top) < threshold &&
+            std::abs(deltaPadding.right) < threshold && std::abs(deltaPadding.bottom) < threshold) {
+          return nullptr;
+        }
+
+        auto newData = oldData;
+        newData.padding = newPadding;
+        return std::make_shared<SafeAreaViewShadowNode::ConcreteState::Data const>(newData);
+      });
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<SafeAreaViewComponentDescriptor>();
+}
+
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<SafeAreaViewShadowNode::ConcreteState const>(state);
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
+{
+  [super finalizeUpdates:updateMask];
+  [self _updateStateIfNecessary];
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _state.reset();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTSafeAreaViewCls(void)
+{
+  return RCTSafeAreaViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTCustomPullToRefreshViewProtocol.h

@@ -0,0 +1,15 @@
+/*
+ * 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>
+
+/**
+ * Denotes a view which implements custom pull to refresh functionality.
+ */
+@protocol RCTCustomPullToRefreshViewProtocol
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.h

@@ -0,0 +1,63 @@
+/*
+ * 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/RCTGenericDelegateSplitter.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * Many `UIScrollView` customizations normally require creating a subclass which is not always convenient.
+ * `RCTEnhancedScrollView` has a delegate (conforming to this protocol) that allows customizing such behaviors without
+ * creating a subclass.
+ */
+@protocol RCTEnhancedScrollViewOverridingDelegate <NSObject>
+
+- (BOOL)touchesShouldCancelInContentView:(UIView *)view;
+
+@end
+
+/*
+ * `UIScrollView` subclass which has some improvements and tweaks
+ * which are not directly related to React Native.
+ */
+@interface RCTEnhancedScrollView : UIScrollView
+
+/*
+ * Returns a delegate splitter that can be used to create as many `UIScrollView` delegates as needed.
+ * Use that instead of accessing `delegate` property directly.
+ *
+ * This class overrides the `delegate` property and wires that to the delegate splitter.
+ *
+ * We never know which another part of the app might introspect the view hierarchy and mess with `UIScrollView`'s
+ * delegate, so we expose a fake delegate connected to the original one via the splitter to make the component as
+ * resilient to other code as possible: even if something else nil the delegate, other delegates that were subscribed
+ * via the splitter will continue working.
+ */
+@property (nonatomic, strong, readonly) RCTGenericDelegateSplitter<id<UIScrollViewDelegate>> *delegateSplitter;
+
+@property (nonatomic, weak) id<RCTEnhancedScrollViewOverridingDelegate> overridingDelegate;
+@property (nonatomic, assign) BOOL pinchGestureEnabled;
+@property (nonatomic, assign) BOOL centerContent;
+@property (nonatomic, assign) CGFloat snapToInterval;
+@property (nonatomic, copy) NSString *snapToAlignment;
+@property (nonatomic, assign) BOOL disableIntervalMomentum;
+@property (nonatomic, assign) BOOL snapToStart;
+@property (nonatomic, assign) BOOL snapToEnd;
+@property (nonatomic, copy) NSArray<NSNumber *> *snapToOffsets;
+
+/*
+ * Makes `setContentOffset:` method no-op when given `block` is executed.
+ * The block is being executed synchronously.
+ */
+- (void)preserveContentOffsetWithBlock:(void (^)())block;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.mm

@@ -0,0 +1,267 @@
+/*
+ * 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 "RCTEnhancedScrollView.h"
+#import <React/RCTUtils.h>
+
+@interface RCTEnhancedScrollView () <UIScrollViewDelegate>
+@end
+
+@implementation RCTEnhancedScrollView {
+  __weak id<UIScrollViewDelegate> _publicDelegate;
+  BOOL _isSetContentOffsetDisabled;
+}
+
++ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key
+{
+  if ([key isEqualToString:@"delegate"]) {
+    // For `delegate` property, we issue KVO notifications manually.
+    // We need that to block notifications caused by setting the original `UIScrollView`s property.
+    return NO;
+  }
+
+  return [super automaticallyNotifiesObserversForKey:key];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    // We set the default behavior to "never" so that iOS
+    // doesn't do weird things to UIScrollView insets automatically
+    // and keeps it as an opt-in behavior.
+    self.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+
+    // We intentionally force `UIScrollView`s `semanticContentAttribute` to `LTR` here
+    // because this attribute affects a position of vertical scrollbar; we don't want this
+    // scrollbar flip because we also flip it with whole `UIScrollView` flip.
+    self.semanticContentAttribute = UISemanticContentAttributeForceLeftToRight;
+
+    __weak __typeof(self) weakSelf = self;
+    _delegateSplitter = [[RCTGenericDelegateSplitter alloc] initWithDelegateUpdateBlock:^(id delegate) {
+      [weakSelf setPrivateDelegate:delegate];
+    }];
+    [_delegateSplitter addDelegate:self];
+  }
+
+  return self;
+}
+
+- (void)preserveContentOffsetWithBlock:(void (^)())block
+{
+  if (!block) {
+    return;
+  }
+
+  _isSetContentOffsetDisabled = YES;
+  block();
+  _isSetContentOffsetDisabled = NO;
+}
+
+/*
+ * Automatically centers the content such that if the content is smaller than the
+ * ScrollView, we force it to be centered, but when you zoom or the content otherwise
+ * becomes larger than the ScrollView, there is no padding around the content but it
+ * can still fill the whole view.
+ */
+- (void)setContentOffset:(CGPoint)contentOffset
+{
+  if (_isSetContentOffsetDisabled) {
+    return;
+  }
+
+  if (_centerContent && !CGSizeEqualToSize(self.contentSize, CGSizeZero)) {
+    CGSize scrollViewSize = self.bounds.size;
+    if (self.contentSize.width <= scrollViewSize.width) {
+      contentOffset.x = -(scrollViewSize.width - self.contentSize.width) / 2.0;
+    }
+    if (self.contentSize.height <= scrollViewSize.height) {
+      contentOffset.y = -(scrollViewSize.height - self.contentSize.height) / 2.0;
+    }
+  }
+
+  super.contentOffset = CGPointMake(
+      RCTSanitizeNaNValue(contentOffset.x, @"scrollView.contentOffset.x"),
+      RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"));
+}
+
+- (BOOL)touchesShouldCancelInContentView:(UIView *)view
+{
+  if ([_overridingDelegate respondsToSelector:@selector(touchesShouldCancelInContentView:)]) {
+    return [_overridingDelegate touchesShouldCancelInContentView:view];
+  }
+
+  return [super touchesShouldCancelInContentView:view];
+}
+
+#pragma mark - RCTGenericDelegateSplitter
+
+- (void)setPrivateDelegate:(id<UIScrollViewDelegate>)delegate
+{
+  [super setDelegate:delegate];
+}
+
+- (id<UIScrollViewDelegate>)delegate
+{
+  return _publicDelegate;
+}
+
+- (void)setDelegate:(id<UIScrollViewDelegate>)delegate
+{
+  if (_publicDelegate == delegate) {
+    return;
+  }
+
+  if (_publicDelegate) {
+    [_delegateSplitter removeDelegate:_publicDelegate];
+  }
+
+  [self willChangeValueForKey:@"delegate"];
+  _publicDelegate = delegate;
+  [self didChangeValueForKey:@"delegate"];
+
+  if (_publicDelegate) {
+    [_delegateSplitter addDelegate:_publicDelegate];
+  }
+}
+
+#pragma mark - UIScrollViewDelegate
+
+- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView
+                     withVelocity:(CGPoint)velocity
+              targetContentOffset:(inout CGPoint *)targetContentOffset
+{
+  if (self.snapToOffsets && self.snapToOffsets.count > 0) {
+    // An alternative to enablePaging and snapToInterval which allows setting custom
+    // stopping points that don't have to be the same distance apart. Often seen in
+    // apps which feature horizonally scrolling items. snapToInterval does not enforce
+    // scrolling one interval at a time but guarantees that the scroll will stop at
+    // a snap offset point.
+
+    // Find which axis to snap
+    BOOL isHorizontal = [self isHorizontal:scrollView];
+    CGFloat velocityAlongAxis = isHorizontal ? velocity.x : velocity.y;
+    CGFloat offsetAlongAxis = isHorizontal ? scrollView.contentOffset.x : scrollView.contentOffset.y;
+
+    // Calculate maximum content offset
+    CGSize viewportSize = self.bounds.size;
+    CGFloat maximumOffset = isHorizontal ? MAX(0, scrollView.contentSize.width - viewportSize.width)
+                                         : MAX(0, scrollView.contentSize.height - viewportSize.height);
+
+    // Calculate the snap offsets adjacent to the initial offset target
+    CGFloat targetOffset = isHorizontal ? targetContentOffset->x : targetContentOffset->y;
+    CGFloat smallerOffset = 0.0;
+    CGFloat largerOffset = maximumOffset;
+
+    for (unsigned long i = 0; i < self.snapToOffsets.count; i++) {
+      CGFloat offset = [[self.snapToOffsets objectAtIndex:i] floatValue];
+
+      if (offset <= targetOffset) {
+        if (targetOffset - offset < targetOffset - smallerOffset) {
+          smallerOffset = offset;
+        }
+      }
+
+      if (offset >= targetOffset) {
+        if (offset - targetOffset < largerOffset - targetOffset) {
+          largerOffset = offset;
+        }
+      }
+    }
+
+    // Calculate the nearest offset
+    CGFloat nearestOffset = targetOffset - smallerOffset < largerOffset - targetOffset ? smallerOffset : largerOffset;
+
+    CGFloat firstOffset = [[self.snapToOffsets firstObject] floatValue];
+    CGFloat lastOffset = [[self.snapToOffsets lastObject] floatValue];
+
+    // if scrolling after the last snap offset and snapping to the
+    // end of the list is disabled, then we allow free scrolling
+    if (!self.snapToEnd && targetOffset >= lastOffset) {
+      if (offsetAlongAxis >= lastOffset) {
+        // free scrolling
+      } else {
+        // snap to end
+        targetOffset = lastOffset;
+      }
+    } else if (!self.snapToStart && targetOffset <= firstOffset) {
+      if (offsetAlongAxis <= firstOffset) {
+        // free scrolling
+      } else {
+        // snap to beginning
+        targetOffset = firstOffset;
+      }
+    } else if (velocityAlongAxis > 0.0) {
+      targetOffset = largerOffset;
+    } else if (velocityAlongAxis < 0.0) {
+      targetOffset = smallerOffset;
+    } else {
+      targetOffset = nearestOffset;
+    }
+
+    // Make sure the new offset isn't out of bounds
+    targetOffset = MIN(MAX(0, targetOffset), maximumOffset);
+
+    // Set new targetContentOffset
+    if (isHorizontal) {
+      targetContentOffset->x = targetOffset;
+    } else {
+      targetContentOffset->y = targetOffset;
+    }
+  } else if (self.snapToInterval) {
+    // An alternative to enablePaging which allows setting custom stopping intervals,
+    // smaller than a full page size. Often seen in apps which feature horizonally
+    // scrolling items. snapToInterval does not enforce scrolling one interval at a time
+    // but guarantees that the scroll will stop at an interval point.
+    CGFloat snapToIntervalF = (CGFloat)self.snapToInterval;
+
+    // Find which axis to snap
+    BOOL isHorizontal = [self isHorizontal:scrollView];
+
+    // What is the current offset?
+    CGFloat velocityAlongAxis = isHorizontal ? velocity.x : velocity.y;
+    CGFloat targetContentOffsetAlongAxis = targetContentOffset->y;
+    if (isHorizontal) {
+      // Use current scroll offset to determine the next index to snap to when momentum disabled
+      targetContentOffsetAlongAxis = self.disableIntervalMomentum ? scrollView.contentOffset.x : targetContentOffset->x;
+    } else {
+      targetContentOffsetAlongAxis = self.disableIntervalMomentum ? scrollView.contentOffset.y : targetContentOffset->y;
+    }
+
+    // Offset based on desired alignment
+    CGFloat frameLength = isHorizontal ? self.frame.size.width : self.frame.size.height;
+    CGFloat alignmentOffset = 0.0f;
+    if ([self.snapToAlignment isEqualToString:@"center"]) {
+      alignmentOffset = (frameLength * 0.5f) + (snapToIntervalF * 0.5f);
+    } else if ([self.snapToAlignment isEqualToString:@"end"]) {
+      alignmentOffset = frameLength;
+    }
+
+    // Pick snap point based on direction and proximity
+    CGFloat fractionalIndex = (targetContentOffsetAlongAxis + alignmentOffset) / snapToIntervalF;
+
+    NSInteger snapIndex = velocityAlongAxis > 0.0 ? ceil(fractionalIndex)
+        : velocityAlongAxis < 0.0                 ? floor(fractionalIndex)
+                                                  : round(fractionalIndex);
+    CGFloat newTargetContentOffset = ((CGFloat)snapIndex * snapToIntervalF) - alignmentOffset;
+
+    // Set new targetContentOffset
+    if (isHorizontal) {
+      targetContentOffset->x = newTargetContentOffset;
+    } else {
+      targetContentOffset->y = newTargetContentOffset;
+    }
+  }
+}
+
+#pragma mark -
+
+- (BOOL)isHorizontal:(UIScrollView *)scrollView
+{
+  return scrollView.contentSize.width > self.frame.size.width;
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTPullToRefreshViewComponentView.h

@@ -0,0 +1,24 @@
+/*
+ * 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/RCTCustomPullToRefreshViewProtocol.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * UIView class for root <PullToRefreshView> component.
+ * This view is designed to only serve ViewController-like purpose for the actual `UIRefreshControl` view which is being
+ * attached to some `UIScrollView` (not to this view).
+ */
+@interface RCTPullToRefreshViewComponentView : RCTViewComponentView <RCTCustomPullToRefreshViewProtocol>
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTPullToRefreshViewComponentView.mm

@@ -0,0 +1,189 @@
+/*
+ * 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 "RCTPullToRefreshViewComponentView.h"
+
+#import <react/renderer/components/rncore/ComponentDescriptors.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+#import <react/renderer/components/rncore/RCTComponentViewHelpers.h>
+
+#import <React/RCTConversions.h>
+#import <React/RCTRefreshableProtocol.h>
+#import <React/RCTScrollViewComponentView.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RCTPullToRefreshViewComponentView () <RCTPullToRefreshViewViewProtocol, RCTRefreshableProtocol>
+@end
+
+@implementation RCTPullToRefreshViewComponentView {
+  UIRefreshControl *_refreshControl;
+  RCTScrollViewComponentView *__weak _scrollViewComponentView;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    // This view is not designed to be visible, it only serves UIViewController-like purpose managing
+    // attaching and detaching of a pull-to-refresh view to a scroll view.
+    // The pull-to-refresh view is not a subview of this view.
+    self.hidden = YES;
+
+    _props = PullToRefreshViewShadowNode::defaultSharedProps();
+
+    _refreshControl = [UIRefreshControl new];
+    [_refreshControl addTarget:self
+                        action:@selector(handleUIControlEventValueChanged)
+              forControlEvents:UIControlEventValueChanged];
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<PullToRefreshViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldConcreteProps = static_cast<const PullToRefreshViewProps &>(*_props);
+  const auto &newConcreteProps = static_cast<const PullToRefreshViewProps &>(*props);
+
+  if (newConcreteProps.refreshing != oldConcreteProps.refreshing) {
+    if (newConcreteProps.refreshing) {
+      [_refreshControl beginRefreshing];
+    } else {
+      [_refreshControl endRefreshing];
+    }
+  }
+
+  BOOL needsUpdateTitle = NO;
+
+  if (newConcreteProps.title != oldConcreteProps.title) {
+    needsUpdateTitle = YES;
+  }
+
+  if (newConcreteProps.titleColor != oldConcreteProps.titleColor) {
+    needsUpdateTitle = YES;
+  }
+
+  if (needsUpdateTitle) {
+    [self _updateTitle];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark -
+
+- (void)handleUIControlEventValueChanged
+{
+  static_cast<const PullToRefreshViewEventEmitter &>(*_eventEmitter).onRefresh({});
+}
+
+- (void)_updateTitle
+{
+  const auto &concreteProps = static_cast<const PullToRefreshViewProps &>(*_props);
+
+  if (concreteProps.title.empty()) {
+    _refreshControl.attributedTitle = nil;
+    return;
+  }
+
+  NSMutableDictionary *attributes = [NSMutableDictionary dictionary];
+  if (concreteProps.titleColor) {
+    attributes[NSForegroundColorAttributeName] = RCTUIColorFromSharedColor(concreteProps.titleColor);
+  }
+
+  _refreshControl.attributedTitle =
+      [[NSAttributedString alloc] initWithString:RCTNSStringFromString(concreteProps.title) attributes:attributes];
+}
+
+#pragma mark - Attaching & Detaching
+
+- (void)didMoveToWindow
+{
+  if (self.window) {
+    [self _attach];
+  } else {
+    [self _detach];
+  }
+}
+
+- (void)_attach
+{
+  if (_scrollViewComponentView) {
+    [self _detach];
+  }
+
+  _scrollViewComponentView = [RCTScrollViewComponentView findScrollViewComponentViewForView:self];
+  if (!_scrollViewComponentView) {
+    return;
+  }
+
+  if (@available(macCatalyst 13.1, *)) {
+    _scrollViewComponentView.scrollView.refreshControl = _refreshControl;
+  }
+}
+
+- (void)_detach
+{
+  if (!_scrollViewComponentView) {
+    return;
+  }
+
+  // iOS requires to end refreshing before unmounting.
+  [_refreshControl endRefreshing];
+
+  if (@available(macCatalyst 13.1, *)) {
+    _scrollViewComponentView.scrollView.refreshControl = nil;
+  }
+  _scrollViewComponentView = nil;
+}
+
+#pragma mark - Native commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTPullToRefreshViewHandleCommand(self, commandName, args);
+}
+
+- (void)setNativeRefreshing:(BOOL)refreshing
+{
+  if (refreshing) {
+    [_refreshControl beginRefreshing];
+  } else {
+    [_refreshControl endRefreshing];
+  }
+}
+
+#pragma mark - RCTRefreshableProtocol
+
+- (void)setRefreshing:(BOOL)refreshing
+{
+  [self setNativeRefreshing:refreshing];
+}
+
+#pragma mark -
+
+- (NSString *)componentViewName_DO_NOT_USE_THIS_IS_BROKEN
+{
+  return @"RefreshControl";
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTPullToRefreshViewCls(void)
+{
+  return RCTPullToRefreshViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.h

@@ -0,0 +1,62 @@
+/*
+ * 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/RCTDefines.h>
+#import <React/RCTGenericDelegateSplitter.h>
+#import <React/RCTMountingTransactionObserving.h>
+#import <React/RCTScrollableProtocol.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * UIView class for <ScrollView> component.
+ *
+ * By design, the class does not implement any logic that contradicts to the normal behavior of UIScrollView and does
+ * not contain any special/custom support for things like floating headers, pull-to-refresh components,
+ * keyboard-avoiding functionality and so on. All that complexity must be implemented inside those components in order
+ * to keep the complexity of this component manageable.
+ */
+@interface RCTScrollViewComponentView : RCTViewComponentView <RCTMountingTransactionObserving>
+
+/*
+ * Finds and returns the closet RCTScrollViewComponentView component to the given view
+ */
++ (nullable RCTScrollViewComponentView *)findScrollViewComponentViewForView:(UIView *)view;
+
+/*
+ * Returns an actual UIScrollView that this component uses under the hood.
+ */
+@property (nonatomic, strong, readonly) UIScrollView *scrollView;
+
+/*
+ * Returns the subview of the scroll view that the component uses to mount all subcomponents into. That's useful to
+ * separate component views from auxiliary views to be able to reliably implement pull-to-refresh- and RTL-related
+ * functionality.
+ */
+@property (nonatomic, strong, readonly) UIView *containerView;
+
+/*
+ * Returns a delegate splitter that can be used to subscribe for UIScrollView delegate.
+ */
+@property (nonatomic, strong, readonly)
+    RCTGenericDelegateSplitter<id<UIScrollViewDelegate>> *scrollViewDelegateSplitter;
+
+@end
+
+/*
+ * RCTScrollableProtocol is a protocol which RCTScrollViewManager uses to communicate with all kinds of `UIScrollView`s.
+ * Until Fabric has own command-execution pipeline we have to support that to some extent. The implementation shouldn't
+ * be perfect though because very soon we will migrate that to the new commands infra and get rid of this.
+ */
+@interface RCTScrollViewComponentView (ScrollableProtocol) <RCTScrollableProtocol>
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm

@@ -0,0 +1,816 @@
+/*
+ * 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 "RCTScrollViewComponentView.h"
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTConstants.h>
+#import <React/RCTScrollEvent.h>
+
+#import <react/renderer/components/scrollview/RCTComponentViewHelpers.h>
+#import <react/renderer/components/scrollview/ScrollViewComponentDescriptor.h>
+#import <react/renderer/components/scrollview/ScrollViewEventEmitter.h>
+#import <react/renderer/components/scrollview/ScrollViewProps.h>
+#import <react/renderer/components/scrollview/ScrollViewState.h>
+#import <react/renderer/components/scrollview/conversions.h>
+
+#import "RCTConversions.h"
+#import "RCTCustomPullToRefreshViewProtocol.h"
+#import "RCTEnhancedScrollView.h"
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+static const CGFloat kClippingLeeway = 44.0;
+
+static UIScrollViewKeyboardDismissMode RCTUIKeyboardDismissModeFromProps(const ScrollViewProps &props)
+{
+  switch (props.keyboardDismissMode) {
+    case ScrollViewKeyboardDismissMode::None:
+      return UIScrollViewKeyboardDismissModeNone;
+    case ScrollViewKeyboardDismissMode::OnDrag:
+      return UIScrollViewKeyboardDismissModeOnDrag;
+    case ScrollViewKeyboardDismissMode::Interactive:
+      return UIScrollViewKeyboardDismissModeInteractive;
+  }
+}
+
+static UIScrollViewIndicatorStyle RCTUIScrollViewIndicatorStyleFromProps(const ScrollViewProps &props)
+{
+  switch (props.indicatorStyle) {
+    case ScrollViewIndicatorStyle::Default:
+      return UIScrollViewIndicatorStyleDefault;
+    case ScrollViewIndicatorStyle::Black:
+      return UIScrollViewIndicatorStyleBlack;
+    case ScrollViewIndicatorStyle::White:
+      return UIScrollViewIndicatorStyleWhite;
+  }
+}
+
+// Once Fabric implements proper NativeAnimationDriver, this should be removed.
+// This is just a workaround to allow animations based on onScroll event.
+// This is only used to animate sticky headers in ScrollViews, and only the contentOffset and tag is used.
+// TODO: T116850910 [Fabric][iOS] Make Fabric not use legacy RCTEventDispatcher for native-driven AnimatedEvents
+static void RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrollView, NSInteger tag)
+{
+  static uint16_t coalescingKey = 0;
+  RCTScrollEvent *scrollEvent = [[RCTScrollEvent alloc] initWithEventName:@"onScroll"
+                                                                 reactTag:[NSNumber numberWithInt:tag]
+                                                  scrollViewContentOffset:scrollView.contentOffset
+                                                   scrollViewContentInset:scrollView.contentInset
+                                                    scrollViewContentSize:scrollView.contentSize
+                                                          scrollViewFrame:scrollView.frame
+                                                      scrollViewZoomScale:scrollView.zoomScale
+                                                                 userData:nil
+                                                            coalescingKey:coalescingKey];
+  RCTBridge *bridge = [RCTBridge currentBridge];
+  if (bridge) {
+    [bridge.eventDispatcher sendEvent:scrollEvent];
+  } else {
+    NSDictionary *userInfo = [NSDictionary dictionaryWithObjectsAndKeys:scrollEvent, @"event", nil];
+    [[NSNotificationCenter defaultCenter] postNotificationName:@"RCTNotifyEventDispatcherObserversOfEvent_DEPRECATED"
+                                                        object:nil
+                                                      userInfo:userInfo];
+  }
+}
+
+@interface RCTScrollViewComponentView () <
+    UIScrollViewDelegate,
+    RCTScrollViewProtocol,
+    RCTScrollableProtocol,
+    RCTEnhancedScrollViewOverridingDelegate>
+
+@end
+
+@implementation RCTScrollViewComponentView {
+  ScrollViewShadowNode::ConcreteState::Shared _state;
+  CGSize _contentSize;
+  NSTimeInterval _lastScrollEventDispatchTime;
+  NSTimeInterval _scrollEventThrottle;
+  // Flag indicating whether the scrolling that is currently happening
+  // is triggered by user or not.
+  // This helps to only update state from `scrollViewDidScroll` in case
+  // some other part of the system scrolls scroll view.
+  BOOL _isUserTriggeredScrolling;
+  BOOL _shouldUpdateContentInsetAdjustmentBehavior;
+
+  CGPoint _contentOffsetWhenClipped;
+
+  __weak UIView *_contentView;
+
+  CGRect _prevFirstVisibleFrame;
+  __weak UIView *_firstVisibleView;
+
+  CGFloat _endDraggingSensitivityMultiplier;
+  CGFloat _endDraggingSensitivityVelocityMultiplier;
+}
+
++ (RCTScrollViewComponentView *_Nullable)findScrollViewComponentViewForView:(UIView *)view
+{
+  do {
+    view = view.superview;
+  } while (view != nil && ![view isKindOfClass:[RCTScrollViewComponentView class]]);
+  return (RCTScrollViewComponentView *)view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = ScrollViewShadowNode::defaultSharedProps();
+
+    _scrollView = [[RCTEnhancedScrollView alloc] initWithFrame:self.bounds];
+    _scrollView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    _scrollView.delaysContentTouches = NO;
+    ((RCTEnhancedScrollView *)_scrollView).overridingDelegate = self;
+    _isUserTriggeredScrolling = NO;
+    _shouldUpdateContentInsetAdjustmentBehavior = YES;
+    [self addSubview:_scrollView];
+
+    _containerView = [[UIView alloc] initWithFrame:CGRectZero];
+    [_scrollView addSubview:_containerView];
+
+    [self.scrollViewDelegateSplitter addDelegate:self];
+
+    _scrollEventThrottle = 0;
+    _endDraggingSensitivityVelocityMultiplier = 0;
+    _endDraggingSensitivityMultiplier = 1;
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  // Removing all delegates from the splitter nils the actual delegate which prevents a crash on UIScrollView
+  // deallocation.
+  [self.scrollViewDelegateSplitter removeAllDelegates];
+}
+
+- (RCTGenericDelegateSplitter<id<UIScrollViewDelegate>> *)scrollViewDelegateSplitter
+{
+  return ((RCTEnhancedScrollView *)_scrollView).delegateSplitter;
+}
+
+#pragma mark - RCTMountingTransactionObserving
+
+- (void)mountingTransactionWillMount:(const facebook::react::MountingTransaction &)transaction
+                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  [self _prepareForMaintainVisibleScrollPosition];
+}
+
+- (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
+               withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  [self _remountChildren];
+  [self _adjustForMaintainVisibleContentPosition];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>();
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  if (layoutMetrics.layoutDirection != oldLayoutMetrics.layoutDirection) {
+    CGAffineTransform transform = (layoutMetrics.layoutDirection == LayoutDirection::LeftToRight)
+        ? CGAffineTransformIdentity
+        : CGAffineTransformMakeScale(-1, 1);
+
+    _containerView.transform = transform;
+    _scrollView.transform = transform;
+  }
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldScrollViewProps = static_cast<const ScrollViewProps &>(*_props);
+  const auto &newScrollViewProps = static_cast<const ScrollViewProps &>(*props);
+
+#define REMAP_PROP(reactName, localName, target)                      \
+  if (oldScrollViewProps.reactName != newScrollViewProps.reactName) { \
+    target.localName = newScrollViewProps.reactName;                  \
+  }
+
+#define REMAP_VIEW_PROP(reactName, localName) REMAP_PROP(reactName, localName, self)
+#define MAP_VIEW_PROP(name) REMAP_VIEW_PROP(name, name)
+#define REMAP_SCROLL_VIEW_PROP(reactName, localName) \
+  REMAP_PROP(reactName, localName, ((RCTEnhancedScrollView *)_scrollView))
+#define MAP_SCROLL_VIEW_PROP(name) REMAP_SCROLL_VIEW_PROP(name, name)
+
+  // FIXME: Commented props are not supported yet.
+  MAP_SCROLL_VIEW_PROP(alwaysBounceHorizontal);
+  MAP_SCROLL_VIEW_PROP(alwaysBounceVertical);
+  MAP_SCROLL_VIEW_PROP(bounces);
+  MAP_SCROLL_VIEW_PROP(bouncesZoom);
+  MAP_SCROLL_VIEW_PROP(canCancelContentTouches);
+  MAP_SCROLL_VIEW_PROP(centerContent);
+  // MAP_SCROLL_VIEW_PROP(automaticallyAdjustContentInsets);
+  MAP_SCROLL_VIEW_PROP(decelerationRate);
+  MAP_SCROLL_VIEW_PROP(directionalLockEnabled);
+  MAP_SCROLL_VIEW_PROP(maximumZoomScale);
+  MAP_SCROLL_VIEW_PROP(minimumZoomScale);
+  MAP_SCROLL_VIEW_PROP(scrollEnabled);
+  MAP_SCROLL_VIEW_PROP(pagingEnabled);
+  MAP_SCROLL_VIEW_PROP(pinchGestureEnabled);
+  MAP_SCROLL_VIEW_PROP(scrollsToTop);
+  MAP_SCROLL_VIEW_PROP(showsHorizontalScrollIndicator);
+  MAP_SCROLL_VIEW_PROP(showsVerticalScrollIndicator);
+
+  if (oldScrollViewProps.scrollIndicatorInsets != newScrollViewProps.scrollIndicatorInsets) {
+    _scrollView.scrollIndicatorInsets = RCTUIEdgeInsetsFromEdgeInsets(newScrollViewProps.scrollIndicatorInsets);
+  }
+
+  if (oldScrollViewProps.indicatorStyle != newScrollViewProps.indicatorStyle) {
+    _scrollView.indicatorStyle = RCTUIScrollViewIndicatorStyleFromProps(newScrollViewProps);
+  }
+
+  _endDraggingSensitivityMultiplier = newScrollViewProps.endDraggingSensitivityMultiplier;
+  _endDraggingSensitivityVelocityMultiplier = newScrollViewProps.endDraggingSensitivityVelocityMultiplier;
+
+  if (oldScrollViewProps.scrollEventThrottle != newScrollViewProps.scrollEventThrottle) {
+    // Zero means "send value only once per significant logical event".
+    // Prop value is in milliseconds.
+    // iOS implementation uses `NSTimeInterval` (in seconds).
+    CGFloat throttleInSeconds = newScrollViewProps.scrollEventThrottle / 1000.0;
+    CGFloat msPerFrame = 1.0 / 60.0;
+    if (throttleInSeconds < 0) {
+      _scrollEventThrottle = INFINITY;
+    } else if (throttleInSeconds <= msPerFrame) {
+      _scrollEventThrottle = 0;
+    } else {
+      _scrollEventThrottle = throttleInSeconds;
+    }
+  }
+
+  MAP_SCROLL_VIEW_PROP(zoomScale);
+
+  if (oldScrollViewProps.contentInset != newScrollViewProps.contentInset) {
+    _scrollView.contentInset = RCTUIEdgeInsetsFromEdgeInsets(newScrollViewProps.contentInset);
+  }
+
+  RCTEnhancedScrollView *scrollView = (RCTEnhancedScrollView *)_scrollView;
+  if (oldScrollViewProps.contentOffset != newScrollViewProps.contentOffset) {
+    _scrollView.contentOffset = RCTCGPointFromPoint(newScrollViewProps.contentOffset);
+  }
+
+  if (oldScrollViewProps.snapToAlignment != newScrollViewProps.snapToAlignment) {
+    scrollView.snapToAlignment = RCTNSStringFromString(toString(newScrollViewProps.snapToAlignment));
+  }
+
+  scrollView.snapToStart = newScrollViewProps.snapToStart;
+  scrollView.snapToEnd = newScrollViewProps.snapToEnd;
+
+  if (oldScrollViewProps.snapToOffsets != newScrollViewProps.snapToOffsets) {
+    NSMutableArray<NSNumber *> *snapToOffsets = [NSMutableArray array];
+    for (const auto &snapToOffset : newScrollViewProps.snapToOffsets) {
+      [snapToOffsets addObject:[NSNumber numberWithFloat:snapToOffset]];
+    }
+    scrollView.snapToOffsets = snapToOffsets;
+  }
+
+  if (oldScrollViewProps.automaticallyAdjustsScrollIndicatorInsets !=
+      newScrollViewProps.automaticallyAdjustsScrollIndicatorInsets) {
+    scrollView.automaticallyAdjustsScrollIndicatorInsets = newScrollViewProps.automaticallyAdjustsScrollIndicatorInsets;
+  }
+
+  if ((oldScrollViewProps.contentInsetAdjustmentBehavior != newScrollViewProps.contentInsetAdjustmentBehavior) ||
+      _shouldUpdateContentInsetAdjustmentBehavior) {
+    const auto contentInsetAdjustmentBehavior = newScrollViewProps.contentInsetAdjustmentBehavior;
+    if (contentInsetAdjustmentBehavior == ContentInsetAdjustmentBehavior::Never) {
+      scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+    } else if (contentInsetAdjustmentBehavior == ContentInsetAdjustmentBehavior::Automatic) {
+      scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAutomatic;
+    } else if (contentInsetAdjustmentBehavior == ContentInsetAdjustmentBehavior::ScrollableAxes) {
+      scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentScrollableAxes;
+    } else if (contentInsetAdjustmentBehavior == ContentInsetAdjustmentBehavior::Always) {
+      scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAlways;
+    }
+    _shouldUpdateContentInsetAdjustmentBehavior = NO;
+  }
+
+  MAP_SCROLL_VIEW_PROP(disableIntervalMomentum);
+  MAP_SCROLL_VIEW_PROP(snapToInterval);
+
+  if (oldScrollViewProps.keyboardDismissMode != newScrollViewProps.keyboardDismissMode) {
+    scrollView.keyboardDismissMode = RCTUIKeyboardDismissModeFromProps(newScrollViewProps);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  assert(std::dynamic_pointer_cast<ScrollViewShadowNode::ConcreteState const>(state));
+  _state = std::static_pointer_cast<ScrollViewShadowNode::ConcreteState const>(state);
+  auto &data = _state->getData();
+
+  auto contentOffset = RCTCGPointFromPoint(data.contentOffset);
+  if (!oldState && !CGPointEqualToPoint(contentOffset, CGPointZero)) {
+    _scrollView.contentOffset = contentOffset;
+  }
+
+  CGSize contentSize = RCTCGSizeFromSize(data.getContentSize());
+
+  if (CGSizeEqualToSize(_contentSize, contentSize)) {
+    return;
+  }
+
+  _contentSize = contentSize;
+  _containerView.frame = CGRect{RCTCGPointFromPoint(data.contentBoundingRect.origin), contentSize};
+
+  [self _preserveContentOffsetIfNeededWithBlock:^{
+    self->_scrollView.contentSize = contentSize;
+  }];
+}
+
+/*
+ * Disables programmatical changing of ScrollView's `contentOffset` if a touch gesture is in progress.
+ */
+- (void)_preserveContentOffsetIfNeededWithBlock:(void (^)())block
+{
+  if (!block) {
+    return;
+  }
+
+  if (!_isUserTriggeredScrolling) {
+    return block();
+  }
+
+  [((RCTEnhancedScrollView *)_scrollView) preserveContentOffsetWithBlock:block];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_containerView insertSubview:childComponentView atIndex:index];
+  if (![childComponentView conformsToProtocol:@protocol(RCTCustomPullToRefreshViewProtocol)]) {
+    _contentView = childComponentView;
+  }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+  if (![childComponentView conformsToProtocol:@protocol(RCTCustomPullToRefreshViewProtocol)] &&
+      _contentView == childComponentView) {
+    _contentView = nil;
+  }
+}
+
+/*
+ * Returns whether or not the scroll view interaction should be blocked because
+ * JavaScript was found to be the responder.
+ */
+- (BOOL)_shouldDisableScrollInteraction
+{
+  UIView *ancestorView = self.superview;
+
+  while (ancestorView) {
+    if ([ancestorView respondsToSelector:@selector(isJSResponder)]) {
+      BOOL isJSResponder = ((UIView<RCTComponentViewProtocol> *)ancestorView).isJSResponder;
+      if (isJSResponder) {
+        return YES;
+      }
+    }
+
+    ancestorView = ancestorView.superview;
+  }
+
+  return NO;
+}
+
+- (ScrollViewMetrics)_scrollViewMetrics
+{
+  ScrollViewMetrics metrics;
+  metrics.contentSize = RCTSizeFromCGSize(_scrollView.contentSize);
+  metrics.contentOffset = RCTPointFromCGPoint(_scrollView.contentOffset);
+  metrics.contentInset = RCTEdgeInsetsFromUIEdgeInsets(_scrollView.contentInset);
+  metrics.containerSize = RCTSizeFromCGSize(_scrollView.bounds.size);
+  metrics.zoomScale = _scrollView.zoomScale;
+
+  if (_layoutMetrics.layoutDirection == LayoutDirection::RightToLeft) {
+    metrics.contentOffset.x = metrics.contentSize.width - metrics.containerSize.width - metrics.contentOffset.x;
+  }
+
+  return metrics;
+}
+
+- (void)_updateStateWithContentOffset
+{
+  if (!_state) {
+    return;
+  }
+  auto contentOffset = RCTPointFromCGPoint(_scrollView.contentOffset);
+  _state->updateState([contentOffset](const ScrollViewShadowNode::ConcreteState::Data &data) {
+    auto newData = data;
+    newData.contentOffset = contentOffset;
+    return std::make_shared<ScrollViewShadowNode::ConcreteState::Data const>(newData);
+  });
+}
+
+- (void)prepareForRecycle
+{
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
+  _scrollView.contentOffset = RCTCGPointFromPoint(props.contentOffset);
+  // We set the default behavior to "never" so that iOS
+  // doesn't do weird things to UIScrollView insets automatically
+  // and keeps it as an opt-in behavior.
+  _scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+  _shouldUpdateContentInsetAdjustmentBehavior = YES;
+  _state.reset();
+  _isUserTriggeredScrolling = NO;
+  CGRect oldFrame = self.frame;
+  self.frame = CGRectZero;
+  self.frame = oldFrame;
+  _contentView = nil;
+  _prevFirstVisibleFrame = CGRectZero;
+  _firstVisibleView = nil;
+  [super prepareForRecycle];
+}
+
+#pragma mark - UIScrollViewDelegate
+
+- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView
+                     withVelocity:(CGPoint)velocity
+              targetContentOffset:(inout CGPoint *)targetContentOffset
+{
+  if (fabs(_endDraggingSensitivityMultiplier - 1) > 0.0001f ||
+      fabs(_endDraggingSensitivityVelocityMultiplier) > 0.0001f) {
+    if (targetContentOffset->y > 0) {
+      const CGFloat travel = targetContentOffset->y - scrollView.contentOffset.y;
+      targetContentOffset->y = scrollView.contentOffset.y + travel * _endDraggingSensitivityMultiplier +
+          velocity.y * _endDraggingSensitivityVelocityMultiplier;
+    }
+  }
+}
+
+- (BOOL)touchesShouldCancelInContentView:(__unused UIView *)view
+{
+  // Historically, `UIScrollView`s in React Native do not cancel touches
+  // started on `UIControl`-based views (as normal iOS `UIScrollView`s do).
+  return ![self _shouldDisableScrollInteraction];
+}
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+  if (!_isUserTriggeredScrolling || CoreFeatures::enableGranularScrollViewStateUpdatesIOS) {
+    [self _updateStateWithContentOffset];
+  }
+
+  NSTimeInterval now = CACurrentMediaTime();
+  if ((_lastScrollEventDispatchTime == 0) || (now - _lastScrollEventDispatchTime > _scrollEventThrottle)) {
+    _lastScrollEventDispatchTime = now;
+    if (_eventEmitter) {
+      static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScroll([self _scrollViewMetrics]);
+    }
+
+    RCTSendScrollEventForNativeAnimations_DEPRECATED(scrollView, self.tag);
+  }
+
+  [self _remountChildrenIfNeeded];
+}
+
+- (void)scrollViewDidZoom:(UIScrollView *)scrollView
+{
+  [self scrollViewDidScroll:scrollView];
+}
+
+- (BOOL)scrollViewShouldScrollToTop:(UIScrollView *)scrollView
+{
+  _isUserTriggeredScrolling = YES;
+  return YES;
+}
+
+- (void)scrollViewDidScrollToTop:(UIScrollView *)scrollView
+{
+  if (!_eventEmitter) {
+    return;
+  }
+
+  _isUserTriggeredScrolling = NO;
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollToTop([self _scrollViewMetrics]);
+  [self _updateStateWithContentOffset];
+}
+
+- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
+{
+  [self _forceDispatchNextScrollEvent];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollBeginDrag([self _scrollViewMetrics]);
+  _isUserTriggeredScrolling = YES;
+}
+
+- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
+{
+  [self _forceDispatchNextScrollEvent];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollEndDrag([self _scrollViewMetrics]);
+
+  [self _updateStateWithContentOffset];
+
+  if (!decelerate) {
+    // ScrollView will not decelerate and `scrollViewDidEndDecelerating` will not be called.
+    // `_isUserTriggeredScrolling` must be set to NO here.
+    _isUserTriggeredScrolling = NO;
+  }
+}
+
+- (void)scrollViewWillBeginDecelerating:(UIScrollView *)scrollView
+{
+  [self _forceDispatchNextScrollEvent];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onMomentumScrollBegin([self _scrollViewMetrics]);
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
+{
+  [self _forceDispatchNextScrollEvent];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onMomentumScrollEnd([self _scrollViewMetrics]);
+  [self _updateStateWithContentOffset];
+  _isUserTriggeredScrolling = NO;
+}
+
+- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
+{
+  [self _handleFinishedScrolling:scrollView];
+}
+
+- (void)_handleFinishedScrolling:(UIScrollView *)scrollView
+{
+  [self _forceDispatchNextScrollEvent];
+  [self scrollViewDidScroll:scrollView];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onMomentumScrollEnd([self _scrollViewMetrics]);
+  [self _updateStateWithContentOffset];
+}
+
+- (void)scrollViewWillBeginZooming:(UIScrollView *)scrollView withView:(nullable UIView *)view
+{
+  [self _forceDispatchNextScrollEvent];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollBeginDrag([self _scrollViewMetrics]);
+}
+
+- (void)scrollViewDidEndZooming:(UIScrollView *)scrollView withView:(nullable UIView *)view atScale:(CGFloat)scale
+{
+  [self _forceDispatchNextScrollEvent];
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollEndDrag([self _scrollViewMetrics]);
+  [self _updateStateWithContentOffset];
+}
+
+- (UIView *)viewForZoomingInScrollView:(__unused UIScrollView *)scrollView
+{
+  return _containerView;
+}
+
+#pragma mark -
+
+- (void)_forceDispatchNextScrollEvent
+{
+  _lastScrollEventDispatchTime = 0;
+}
+
+#pragma mark - Native commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTScrollViewHandleCommand(self, commandName, args);
+}
+
+- (void)flashScrollIndicators
+{
+  [_scrollView flashScrollIndicators];
+}
+
+- (void)scrollTo:(double)x y:(double)y animated:(BOOL)animated
+{
+  CGPoint offset = CGPointMake(x, y);
+  CGRect maxRect = CGRectMake(
+      fmin(-_scrollView.contentInset.left, 0),
+      fmin(-_scrollView.contentInset.top, 0),
+      fmax(
+          _scrollView.contentSize.width - _scrollView.bounds.size.width + _scrollView.contentInset.right +
+              fmax(_scrollView.contentInset.left, 0),
+          0.01),
+      fmax(
+          _scrollView.contentSize.height - _scrollView.bounds.size.height + _scrollView.contentInset.bottom +
+              fmax(_scrollView.contentInset.top, 0),
+          0.01)); // Make width and height greater than 0
+
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
+  if (!CGRectContainsPoint(maxRect, offset) && !props.scrollToOverflowEnabled) {
+    CGFloat localX = fmax(offset.x, CGRectGetMinX(maxRect));
+    localX = fmin(localX, CGRectGetMaxX(maxRect));
+    CGFloat localY = fmax(offset.y, CGRectGetMinY(maxRect));
+    localY = fmin(localY, CGRectGetMaxY(maxRect));
+    offset = CGPointMake(localX, localY);
+  }
+
+  [self scrollToOffset:offset animated:animated];
+}
+
+- (void)scrollToEnd:(BOOL)animated
+{
+  BOOL isHorizontal = _scrollView.contentSize.width > self.frame.size.width;
+  CGPoint offset;
+  if (isHorizontal) {
+    CGFloat offsetX = _scrollView.contentSize.width - _scrollView.bounds.size.width + _scrollView.contentInset.right;
+    offset = CGPointMake(fmax(offsetX, 0), 0);
+  } else {
+    CGFloat offsetY = _scrollView.contentSize.height - _scrollView.bounds.size.height + _scrollView.contentInset.bottom;
+    offset = CGPointMake(0, fmax(offsetY, 0));
+  }
+
+  [self scrollToOffset:offset animated:animated];
+}
+
+#pragma mark - Child views mounting
+
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
+{
+  // Do nothing. ScrollView manages its subview clipping individually in `_remountChildren`.
+}
+
+- (void)_remountChildrenIfNeeded
+{
+  CGPoint contentOffset = _scrollView.contentOffset;
+
+  if (std::abs(_contentOffsetWhenClipped.x - contentOffset.x) < kClippingLeeway &&
+      std::abs(_contentOffsetWhenClipped.y - contentOffset.y) < kClippingLeeway) {
+    return;
+  }
+
+  _contentOffsetWhenClipped = contentOffset;
+
+  [self _remountChildren];
+}
+
+- (void)_remountChildren
+{
+  [_scrollView updateClippedSubviewsWithClipRect:CGRectInset(_scrollView.bounds, -kClippingLeeway, -kClippingLeeway)
+                                  relativeToView:_scrollView];
+}
+
+#pragma mark - RCTScrollableProtocol
+
+- (CGSize)contentSize
+{
+  return _contentSize;
+}
+
+- (void)scrollToOffset:(CGPoint)offset
+{
+  [self scrollToOffset:offset animated:YES];
+}
+
+- (void)scrollToOffset:(CGPoint)offset animated:(BOOL)animated
+{
+  if (_layoutMetrics.layoutDirection == LayoutDirection::RightToLeft) {
+    // Adjusting offset.x in right to left layout direction.
+    offset.x = self.contentSize.width - _scrollView.frame.size.width - offset.x;
+  }
+
+  if (CGPointEqualToPoint(_scrollView.contentOffset, offset)) {
+    return;
+  }
+
+  [self _forceDispatchNextScrollEvent];
+
+  [_scrollView setContentOffset:offset animated:animated];
+
+  if (!animated) {
+    // When not animated, the expected workflow in ``scrollViewDidEndScrollingAnimation`` after scrolling is not going
+    // to get triggered. We will need to manually execute here.
+    [self _handleFinishedScrolling:_scrollView];
+  }
+}
+
+- (void)zoomToRect:(CGRect)rect animated:(BOOL)animated
+{
+  [_scrollView zoomToRect:rect animated:animated];
+}
+
+- (void)addScrollListener:(NSObject<UIScrollViewDelegate> *)scrollListener
+{
+  [self.scrollViewDelegateSplitter addDelegate:scrollListener];
+}
+
+- (void)removeScrollListener:(NSObject<UIScrollViewDelegate> *)scrollListener
+{
+  [self.scrollViewDelegateSplitter removeDelegate:scrollListener];
+}
+
+#pragma mark - Maintain visible content position
+
+- (void)_prepareForMaintainVisibleScrollPosition
+{
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
+  if (!props.maintainVisibleContentPosition) {
+    return;
+  }
+
+  BOOL horizontal = _scrollView.contentSize.width > self.frame.size.width;
+  int minIdx = props.maintainVisibleContentPosition.value().minIndexForVisible;
+  for (NSUInteger ii = minIdx; ii < _contentView.subviews.count; ++ii) {
+    // Find the first entirely visible view.
+    UIView *subview = _contentView.subviews[ii];
+    BOOL hasNewView = NO;
+    if (horizontal) {
+      hasNewView = subview.frame.origin.x > _scrollView.contentOffset.x;
+    } else {
+      hasNewView = subview.frame.origin.y > _scrollView.contentOffset.y;
+    }
+    if (hasNewView || ii == _contentView.subviews.count - 1) {
+      _prevFirstVisibleFrame = subview.frame;
+      _firstVisibleView = subview;
+      break;
+    }
+  }
+}
+
+- (void)_adjustForMaintainVisibleContentPosition
+{
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
+  if (!props.maintainVisibleContentPosition) {
+    return;
+  }
+
+  std::optional<int> autoscrollThreshold = props.maintainVisibleContentPosition.value().autoscrollToTopThreshold;
+  BOOL horizontal = _scrollView.contentSize.width > self.frame.size.width;
+  // TODO: detect and handle/ignore re-ordering
+  if (horizontal) {
+    CGFloat deltaX = _firstVisibleView.frame.origin.x - _prevFirstVisibleFrame.origin.x;
+    if (ABS(deltaX) > 0.5) {
+      CGFloat x = _scrollView.contentOffset.x;
+      [self _forceDispatchNextScrollEvent];
+      _scrollView.contentOffset = CGPointMake(_scrollView.contentOffset.x + deltaX, _scrollView.contentOffset.y);
+      if (autoscrollThreshold) {
+        // If the offset WAS within the threshold of the start, animate to the start.
+        if (x <= autoscrollThreshold.value()) {
+          [self scrollToOffset:CGPointMake(0, _scrollView.contentOffset.y) animated:YES];
+        }
+      }
+    }
+  } else {
+    CGRect newFrame = _firstVisibleView.frame;
+    CGFloat deltaY = newFrame.origin.y - _prevFirstVisibleFrame.origin.y;
+    if (ABS(deltaY) > 0.5) {
+      CGFloat y = _scrollView.contentOffset.y;
+      [self _forceDispatchNextScrollEvent];
+      _scrollView.contentOffset = CGPointMake(_scrollView.contentOffset.x, _scrollView.contentOffset.y + deltaY);
+      if (autoscrollThreshold) {
+        // If the offset WAS within the threshold of the start, animate to the start.
+        if (y <= autoscrollThreshold.value()) {
+          [self scrollToOffset:CGPointMake(_scrollView.contentOffset.x, 0) animated:YES];
+        }
+      }
+    }
+  }
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTScrollViewCls(void)
+{
+  return RCTScrollViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Switch/RCTSwitchComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for root <Switch> component.
+ */
+@interface RCTSwitchComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Switch/RCTSwitchComponentView.mm

@@ -0,0 +1,120 @@
+/*
+ * 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 "RCTSwitchComponentView.h"
+
+#import <React/RCTConversions.h>
+
+#import <react/renderer/components/rncore/ComponentDescriptors.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+#import <react/renderer/components/rncore/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RCTSwitchComponentView () <RCTSwitchViewProtocol>
+@end
+
+@implementation RCTSwitchComponentView {
+  UISwitch *_switchView;
+  BOOL _isInitialValueSet;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = SwitchShadowNode::defaultSharedProps();
+
+    _switchView = [[UISwitch alloc] initWithFrame:self.bounds];
+
+    [_switchView addTarget:self action:@selector(onChange:) forControlEvents:UIControlEventValueChanged];
+
+    self.contentView = _switchView;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _isInitialValueSet = NO;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<SwitchComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldSwitchProps = static_cast<const SwitchProps &>(*_props);
+  const auto &newSwitchProps = static_cast<const SwitchProps &>(*props);
+
+  // `value`
+  if (oldSwitchProps.value != newSwitchProps.value) {
+    BOOL shouldAnimate = _isInitialValueSet == YES;
+    [_switchView setOn:newSwitchProps.value animated:shouldAnimate];
+    _isInitialValueSet = YES;
+  }
+
+  // `disabled`
+  if (oldSwitchProps.disabled != newSwitchProps.disabled) {
+    _switchView.enabled = !newSwitchProps.disabled;
+  }
+
+  // `tintColor`
+  if (oldSwitchProps.tintColor != newSwitchProps.tintColor) {
+    _switchView.tintColor = RCTUIColorFromSharedColor(newSwitchProps.tintColor);
+  }
+
+  // `onTintColor
+  if (oldSwitchProps.onTintColor != newSwitchProps.onTintColor) {
+    _switchView.onTintColor = RCTUIColorFromSharedColor(newSwitchProps.onTintColor);
+  }
+
+  // `thumbTintColor`
+  if (oldSwitchProps.thumbTintColor != newSwitchProps.thumbTintColor) {
+    _switchView.thumbTintColor = RCTUIColorFromSharedColor(newSwitchProps.thumbTintColor);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)onChange:(UISwitch *)sender
+{
+  const auto &props = static_cast<const SwitchProps &>(*_props);
+  if (props.value == sender.on) {
+    return;
+  }
+
+  static_cast<const SwitchEventEmitter &>(*_eventEmitter)
+      .onChange(SwitchEventEmitter::OnChange{.value = static_cast<bool>(sender.on)});
+}
+
+#pragma mark - Native Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTSwitchHandleCommand(self, commandName, args);
+}
+
+- (void)setValue:(BOOL)value
+{
+  [_switchView setOn:value animated:YES];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTSwitchCls(void)
+{
+  return RCTSwitchComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTAccessibilityElement.h

@@ -0,0 +1,23 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTAccessibilityElement : UIAccessibilityElement
+
+/*
+ * Frame of the accessibility element in parent coordinate system.
+ * Set to `CGRectZero` to use size of the container.
+ *
+ * Default value: `CGRectZero`.
+ */
+@property (nonatomic, assign) CGRect frame;
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTAccessibilityElement.mm

@@ -0,0 +1,22 @@
+/*
+ * 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 "RCTAccessibilityElement.h"
+
+@implementation RCTAccessibilityElement
+
+- (CGRect)accessibilityFrame
+{
+  UIView *container = (UIView *)self.accessibilityContainer;
+  if (CGRectEqualToRect(_frame, CGRectZero)) {
+    return UIAccessibilityConvertFrameToScreenCoordinates(container.bounds, container);
+  } else {
+    return UIAccessibilityConvertFrameToScreenCoordinates(_frame, container);
+  }
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentAccessibilityProvider.h

@@ -0,0 +1,34 @@
+/*
+ * 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/renderer/attributedstring/AttributedString.h>
+#import <react/renderer/attributedstring/ParagraphAttributes.h>
+#import <react/renderer/textlayoutmanager/RCTTextLayoutManager.h>
+
+#import "RCTParagraphComponentView.h"
+
+@interface RCTParagraphComponentAccessibilityProvider : NSObject
+
+- (instancetype)initWithString:(facebook::react::AttributedString)attributedString
+                 layoutManager:(RCTTextLayoutManager *)layoutManager
+           paragraphAttributes:(facebook::react::ParagraphAttributes)paragraphAttributes
+                         frame:(CGRect)frame
+                          view:(UIView *)view;
+
+/*
+ * Returns an array of `UIAccessibilityElement`s to be used for `UIAccessibilityContainer` implementation.
+ */
+- (NSArray<UIAccessibilityElement *> *)accessibilityElements;
+
+/**
+ @abstract To make sure the provider is up to date.
+*/
+- (BOOL)isUpToDate:(facebook::react::AttributedString)currentAttributedString;
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentAccessibilityProvider.mm

@@ -0,0 +1,181 @@
+/*
+ * 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 "RCTParagraphComponentAccessibilityProvider.h"
+
+#import <Foundation/Foundation.h>
+#import <react/renderer/components/text/ParagraphProps.h>
+#import <react/renderer/textlayoutmanager/RCTAttributedTextUtils.h>
+#import <react/renderer/textlayoutmanager/RCTTextLayoutManager.h>
+#import <react/renderer/textlayoutmanager/TextLayoutManager.h>
+
+#import "RCTAccessibilityElement.h"
+#import "RCTConversions.h"
+#import "RCTFabricComponentsPlugins.h"
+#import "RCTLocalizationProvider.h"
+
+using namespace facebook::react;
+
+@implementation RCTParagraphComponentAccessibilityProvider {
+  NSMutableArray<UIAccessibilityElement *> *_accessibilityElements;
+  AttributedString _attributedString;
+  RCTTextLayoutManager *_layoutManager;
+  ParagraphAttributes _paragraphAttributes;
+  CGRect _frame;
+  __weak UIView *_view;
+}
+
+- (instancetype)initWithString:(facebook::react::AttributedString)attributedString
+                 layoutManager:(RCTTextLayoutManager *)layoutManager
+           paragraphAttributes:(ParagraphAttributes)paragraphAttributes
+                         frame:(CGRect)frame
+                          view:(UIView *)view
+{
+  if (self = [super init]) {
+    _attributedString = attributedString;
+    _layoutManager = layoutManager;
+    _paragraphAttributes = paragraphAttributes;
+    _frame = frame;
+    _view = view;
+  }
+  return self;
+}
+
+- (NSArray<UIAccessibilityElement *> *)accessibilityElements
+{
+  if (_accessibilityElements) {
+    return _accessibilityElements;
+  }
+
+  __block NSInteger numberOfLinks = 0;
+  __block NSInteger numberOfButtons = 0;
+  __block NSString *truncatedText;
+  // build an array of the accessibleElements
+  NSMutableArray<UIAccessibilityElement *> *elements = [NSMutableArray new];
+
+  NSString *accessibilityLabel = _view.accessibilityLabel;
+  if (accessibilityLabel.length == 0) {
+    accessibilityLabel = RCTNSStringFromString(_attributedString.getString());
+  }
+  // add first element has the text for the whole textview in order to read out the whole text
+  RCTAccessibilityElement *firstElement =
+      [[RCTAccessibilityElement alloc] initWithAccessibilityContainer:_view.superview];
+  firstElement.isAccessibilityElement = YES;
+  firstElement.accessibilityTraits = _view.accessibilityTraits;
+  firstElement.accessibilityLabel = accessibilityLabel;
+  firstElement.accessibilityLanguage = _view.accessibilityLanguage;
+  firstElement.accessibilityFrame = UIAccessibilityConvertFrameToScreenCoordinates(_view.bounds, _view);
+  [firstElement setAccessibilityActivationPoint:CGPointMake(
+                                                    firstElement.accessibilityFrame.origin.x + 1.0,
+                                                    firstElement.accessibilityFrame.origin.y + 1.0)];
+  [elements addObject:firstElement];
+
+  // add additional elements for those parts of text with embedded link so VoiceOver could specially recognize links
+
+  [_layoutManager getRectWithAttributedString:_attributedString
+                          paragraphAttributes:_paragraphAttributes
+                           enumerateAttribute:RCTTextAttributesAccessibilityRoleAttributeName
+                                        frame:_frame
+                                   usingBlock:^(CGRect fragmentRect, NSString *_Nonnull fragmentText, NSString *value) {
+                                     if ([fragmentText isEqualToString:firstElement.accessibilityLabel]) {
+                                       // The fragment is the entire paragraph. This is handled as `firstElement`.
+                                       return;
+                                     }
+                                     if ((![value isEqualToString:@"button"] && ![value isEqualToString:@"link"])) {
+                                       return;
+                                     }
+                                     if ([value isEqualToString:@"button"] &&
+                                         ([fragmentText isEqualToString:@"See Less"] ||
+                                          [fragmentText isEqualToString:@"See More"])) {
+                                       truncatedText = fragmentText;
+                                       return;
+                                     }
+                                     RCTAccessibilityElement *element =
+                                         [[RCTAccessibilityElement alloc] initWithAccessibilityContainer:self->_view];
+                                     element.isAccessibilityElement = YES;
+                                     if ([value isEqualToString:@"link"]) {
+                                       element.accessibilityTraits = UIAccessibilityTraitLink;
+                                       numberOfLinks++;
+                                     } else if ([value isEqualToString:@"button"]) {
+                                       element.accessibilityTraits = UIAccessibilityTraitButton;
+                                       numberOfButtons++;
+                                     }
+                                     element.accessibilityLabel = fragmentText;
+                                     element.frame = fragmentRect;
+                                     [elements addObject:element];
+                                   }];
+
+  if (numberOfLinks > 0 || numberOfButtons > 0) {
+    __block NSInteger indexOfLink = 1;
+    __block NSInteger indexOfButton = 1;
+    [elements enumerateObjectsUsingBlock:^(UIAccessibilityElement *element, NSUInteger idx, BOOL *_Nonnull stop) {
+      if (idx == 0) {
+        return;
+      }
+      if (element.accessibilityTraits & UIAccessibilityTraitLink) {
+        NSString *test = [RCTLocalizationProvider RCTLocalizedString:@"Link %ld of %ld."
+                                                     withDescription:@"index of the link"];
+        element.accessibilityHint = [NSString stringWithFormat:test, (long)indexOfLink++, (long)numberOfLinks];
+      } else {
+        element.accessibilityHint =
+            [NSString stringWithFormat:[RCTLocalizationProvider RCTLocalizedString:@"Button %ld of %ld."
+                                                                   withDescription:@"index of the button"],
+                                       (long)indexOfButton++,
+                                       (long)numberOfButtons];
+      }
+    }];
+  }
+
+  if (numberOfLinks > 0 && numberOfButtons > 0) {
+    firstElement.accessibilityHint =
+        [RCTLocalizationProvider RCTLocalizedString:@"Links and buttons are found, swipe to move to them."
+                                    withDescription:@"accessibility hint for links and buttons inside text"];
+
+  } else if (numberOfLinks > 0) {
+    NSString *firstElementHint = (numberOfLinks == 1)
+        ? [RCTLocalizationProvider RCTLocalizedString:@"One link found, swipe to move to the link."
+                                      withDescription:@"accessibility hint for one link inside text"]
+        : [NSString stringWithFormat:[RCTLocalizationProvider
+                                         RCTLocalizedString:@"%ld links found, swipe to move to the first link."
+                                            withDescription:@"accessibility hint for multiple links inside text"],
+                                     (long)numberOfLinks];
+    firstElement.accessibilityHint = firstElementHint;
+
+  } else if (numberOfButtons > 0) {
+    NSString *firstElementHint = (numberOfButtons == 1)
+        ? [RCTLocalizationProvider RCTLocalizedString:@"One button found, swipe to move to the button."
+                                      withDescription:@"accessibility hint for one button inside text"]
+        : [NSString stringWithFormat:[RCTLocalizationProvider
+                                         RCTLocalizedString:@"%ld buttons found, swipe to move to the first button."
+                                            withDescription:@"accessibility hint for multiple buttons inside text"],
+                                     (long)numberOfButtons];
+    firstElement.accessibilityHint = firstElementHint;
+  }
+
+  if (truncatedText && truncatedText.length > 0) {
+    firstElement.accessibilityHint = (numberOfLinks > 0 || numberOfButtons > 0)
+        ? [NSString
+              stringWithFormat:@"%@ %@",
+                               firstElement.accessibilityHint,
+                               [RCTLocalizationProvider
+                                   RCTLocalizedString:[NSString stringWithFormat:@"Double tap to %@.", truncatedText]
+                                      withDescription:@"accessibility hint for truncated text with links or buttons"]]
+        : [RCTLocalizationProvider RCTLocalizedString:[NSString stringWithFormat:@"Double tap to %@.", truncatedText]
+                                      withDescription:@"accessibility hint for truncated text"];
+  }
+
+  // add accessible element for truncation attributed string for automation purposes only
+  _accessibilityElements = elements;
+  return _accessibilityElements;
+}
+
+- (BOOL)isUpToDate:(facebook::react::AttributedString)currentAttributedString
+{
+  return currentAttributedString == _attributedString;
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentView.h

@@ -0,0 +1,27 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * UIView class for <Paragraph> component.
+ */
+@interface RCTParagraphComponentView : RCTViewComponentView
+
+/*
+ * Returns an `NSAttributedString` representing the content of the component.
+ * To be only used by external introspection and debug tools.
+ */
+@property (nonatomic, nullable, readonly) NSAttributedString *attributedText;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentView.mm

@@ -0,0 +1,298 @@
+/*
+ * 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 "RCTParagraphComponentView.h"
+#import "RCTParagraphComponentAccessibilityProvider.h"
+
+#import <MobileCoreServices/UTCoreTypes.h>
+#import <react/renderer/components/text/ParagraphComponentDescriptor.h>
+#import <react/renderer/components/text/ParagraphProps.h>
+#import <react/renderer/components/text/ParagraphState.h>
+#import <react/renderer/components/text/RawTextComponentDescriptor.h>
+#import <react/renderer/components/text/TextComponentDescriptor.h>
+#import <react/renderer/textlayoutmanager/RCTAttributedTextUtils.h>
+#import <react/renderer/textlayoutmanager/RCTTextLayoutManager.h>
+#import <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+#import "RCTConversions.h"
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RCTParagraphComponentView () <UIEditMenuInteractionDelegate>
+
+@property (nonatomic, nullable) UIEditMenuInteraction *editMenuInteraction API_AVAILABLE(ios(16.0));
+
+@end
+
+@implementation RCTParagraphComponentView {
+  ParagraphShadowNode::ConcreteState::Shared _state;
+  ParagraphAttributes _paragraphAttributes;
+  RCTParagraphComponentAccessibilityProvider *_accessibilityProvider;
+  UILongPressGestureRecognizer *_longPressGestureRecognizer;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = ParagraphShadowNode::defaultSharedProps();
+
+    self.opaque = NO;
+    self.contentMode = UIViewContentModeRedraw;
+  }
+
+  return self;
+}
+
+- (NSString *)description
+{
+  NSString *superDescription = [super description];
+
+  // Cutting the last `>` character.
+  if (superDescription.length > 0 && [superDescription characterAtIndex:superDescription.length - 1] == '>') {
+    superDescription = [superDescription substringToIndex:superDescription.length - 1];
+  }
+
+  return [NSString stringWithFormat:@"%@; attributedText = %@>", superDescription, self.attributedText];
+}
+
+- (NSAttributedString *_Nullable)attributedText
+{
+  if (!_state) {
+    return nil;
+  }
+
+  return RCTNSAttributedStringFromAttributedString(_state->getData().attributedString);
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<ParagraphComponentDescriptor>();
+}
+
++ (std::vector<facebook::react::ComponentDescriptorProvider>)supplementalComponentDescriptorProviders
+{
+  return {
+      concreteComponentDescriptorProvider<RawTextComponentDescriptor>(),
+      concreteComponentDescriptorProvider<TextComponentDescriptor>()};
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldParagraphProps = static_cast<const ParagraphProps &>(*_props);
+  const auto &newParagraphProps = static_cast<const ParagraphProps &>(*props);
+
+  _paragraphAttributes = newParagraphProps.paragraphAttributes;
+
+  if (newParagraphProps.isSelectable != oldParagraphProps.isSelectable) {
+    if (newParagraphProps.isSelectable) {
+      [self enableContextMenu];
+    } else {
+      [self disableContextMenu];
+    }
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<ParagraphShadowNode::ConcreteState const>(state);
+  [self setNeedsDisplay];
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _state.reset();
+  _accessibilityProvider = nil;
+}
+
+- (void)drawRect:(CGRect)rect
+{
+  if (!_state) {
+    return;
+  }
+
+  auto textLayoutManager = _state->getData().paragraphLayoutManager.getTextLayoutManager();
+  auto nsTextStorage = _state->getData().paragraphLayoutManager.getHostTextStorage();
+
+  RCTTextLayoutManager *nativeTextLayoutManager =
+      (RCTTextLayoutManager *)unwrapManagedObject(textLayoutManager->getNativeTextLayoutManager());
+
+  CGRect frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+
+  [nativeTextLayoutManager drawAttributedString:_state->getData().attributedString
+                            paragraphAttributes:_paragraphAttributes
+                                          frame:frame
+                                    textStorage:unwrapManagedObject(nsTextStorage)];
+}
+
+#pragma mark - Accessibility
+
+- (NSString *)accessibilityLabel
+{
+  return self.attributedText.string;
+}
+
+- (BOOL)isAccessibilityElement
+{
+  // All accessibility functionality of the component is implemented in `accessibilityElements` method below.
+  // Hence to avoid calling all other methods from `UIAccessibilityContainer` protocol (most of them have default
+  // implementations), we return here `NO`.
+  return NO;
+}
+
+- (NSArray *)accessibilityElements
+{
+  const auto &paragraphProps = static_cast<const ParagraphProps &>(*_props);
+
+  // If the component is not `accessible`, we return an empty array.
+  // We do this because logically all nested <Text> components represent the content of the <Paragraph> component;
+  // in other words, all nested <Text> components individually have no sense without the <Paragraph>.
+  if (!_state || !paragraphProps.accessible) {
+    return [NSArray new];
+  }
+
+  auto &data = _state->getData();
+
+  if (![_accessibilityProvider isUpToDate:data.attributedString]) {
+    auto textLayoutManager = data.paragraphLayoutManager.getTextLayoutManager();
+    RCTTextLayoutManager *nativeTextLayoutManager =
+        (RCTTextLayoutManager *)unwrapManagedObject(textLayoutManager->getNativeTextLayoutManager());
+    CGRect frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+    _accessibilityProvider = [[RCTParagraphComponentAccessibilityProvider alloc] initWithString:data.attributedString
+                                                                                  layoutManager:nativeTextLayoutManager
+                                                                            paragraphAttributes:data.paragraphAttributes
+                                                                                          frame:frame
+                                                                                           view:self];
+  }
+
+  return _accessibilityProvider.accessibilityElements;
+}
+
+- (UIAccessibilityTraits)accessibilityTraits
+{
+  return [super accessibilityTraits] | UIAccessibilityTraitStaticText;
+}
+
+#pragma mark - RCTTouchableComponentViewProtocol
+
+- (SharedTouchEventEmitter)touchEventEmitterAtPoint:(CGPoint)point
+{
+  if (!_state) {
+    return _eventEmitter;
+  }
+
+  auto textLayoutManager = _state->getData().paragraphLayoutManager.getTextLayoutManager();
+
+  RCTTextLayoutManager *nativeTextLayoutManager =
+      (RCTTextLayoutManager *)unwrapManagedObject(textLayoutManager->getNativeTextLayoutManager());
+  CGRect frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+
+  auto eventEmitter = [nativeTextLayoutManager getEventEmitterWithAttributeString:_state->getData().attributedString
+                                                              paragraphAttributes:_paragraphAttributes
+                                                                            frame:frame
+                                                                          atPoint:point];
+
+  if (!eventEmitter) {
+    return _eventEmitter;
+  }
+
+  assert(std::dynamic_pointer_cast<const TouchEventEmitter>(eventEmitter));
+  return std::static_pointer_cast<const TouchEventEmitter>(eventEmitter);
+}
+
+#pragma mark - Context Menu
+
+- (void)enableContextMenu
+{
+  _longPressGestureRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self
+                                                                              action:@selector(handleLongPress:)];
+
+  if (@available(iOS 16.0, *)) {
+    _editMenuInteraction = [[UIEditMenuInteraction alloc] initWithDelegate:self];
+    [self addInteraction:_editMenuInteraction];
+  }
+  [self addGestureRecognizer:_longPressGestureRecognizer];
+}
+
+- (void)disableContextMenu
+{
+  [self removeGestureRecognizer:_longPressGestureRecognizer];
+  if (@available(iOS 16.0, *)) {
+    [self removeInteraction:_editMenuInteraction];
+    _editMenuInteraction = nil;
+  }
+  _longPressGestureRecognizer = nil;
+}
+
+- (void)handleLongPress:(UILongPressGestureRecognizer *)gesture
+{
+  if (@available(iOS 16.0, macCatalyst 16.0, *)) {
+    CGPoint location = [gesture locationInView:self];
+    UIEditMenuConfiguration *config = [UIEditMenuConfiguration configurationWithIdentifier:nil sourcePoint:location];
+    if (_editMenuInteraction) {
+      [_editMenuInteraction presentEditMenuWithConfiguration:config];
+    }
+  } else {
+    UIMenuController *menuController = [UIMenuController sharedMenuController];
+
+    if (menuController.isMenuVisible) {
+      return;
+    }
+
+    [menuController showMenuFromView:self rect:self.bounds];
+  }
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  const auto &paragraphProps = static_cast<const ParagraphProps &>(*_props);
+  return paragraphProps.isSelectable;
+}
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+  const auto &paragraphProps = static_cast<const ParagraphProps &>(*_props);
+
+  if (paragraphProps.isSelectable && action == @selector(copy:)) {
+    return YES;
+  }
+
+  return [self.nextResponder canPerformAction:action withSender:sender];
+}
+
+- (void)copy:(id)sender
+{
+  NSAttributedString *attributedText = self.attributedText;
+
+  NSMutableDictionary *item = [NSMutableDictionary new];
+
+  NSData *rtf = [attributedText dataFromRange:NSMakeRange(0, attributedText.length)
+                           documentAttributes:@{NSDocumentTypeDocumentAttribute : NSRTFDTextDocumentType}
+                                        error:nil];
+
+  if (rtf) {
+    [item setObject:rtf forKey:(id)kUTTypeFlatRTFD];
+  }
+
+  [item setObject:attributedText.string forKey:(id)kUTTypeUTF8PlainText];
+
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  pasteboard.items = @[ item ];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTParagraphCls(void)
+{
+  return RCTParagraphComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for <TextInput> component.
+ */
+@interface RCTTextInputComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.mm

@@ -0,0 +1,674 @@
+/*
+ * 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 "RCTTextInputComponentView.h"
+
+#import <react/renderer/components/iostextinput/TextInputComponentDescriptor.h>
+#import <react/renderer/textlayoutmanager/RCTAttributedTextUtils.h>
+#import <react/renderer/textlayoutmanager/TextLayoutManager.h>
+
+#import <React/RCTBackedTextInputViewProtocol.h>
+#import <React/RCTUITextField.h>
+#import <React/RCTUITextView.h>
+#import <React/RCTUtils.h>
+
+#import "RCTConversions.h"
+#import "RCTTextInputNativeCommands.h"
+#import "RCTTextInputUtils.h"
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RCTTextInputComponentView () <RCTBackedTextInputDelegate, RCTTextInputViewProtocol>
+@end
+
+@implementation RCTTextInputComponentView {
+  TextInputShadowNode::ConcreteState::Shared _state;
+  UIView<RCTBackedTextInputViewProtocol> *_backedTextInputView;
+  NSUInteger _mostRecentEventCount;
+  NSAttributedString *_lastStringStateWasUpdatedWith;
+
+  /*
+   * UIKit uses either UITextField or UITextView as its UIKit element for <TextInput>. UITextField is for single line
+   * entry, UITextView is for multiline entry. There is a problem with order of events when user types a character. In
+   * UITextField (single line text entry), typing a character first triggers `onChange` event and then
+   * onSelectionChange. In UITextView (multi line text entry), typing a character first triggers `onSelectionChange` and
+   * then onChange. JavaScript depends on `onChange` to be called before `onSelectionChange`. This flag keeps state so
+   * if UITextView is backing text input view, inside `-[RCTTextInputComponentView textInputDidChangeSelection]` we make
+   * sure to call `onChange` before `onSelectionChange` and ignore next `-[RCTTextInputComponentView
+   * textInputDidChange]` call.
+   */
+  BOOL _ignoreNextTextInputCall;
+
+  /*
+   * A flag that when set to true, `_mostRecentEventCount` won't be incremented when `[self _updateState]`
+   * and delegate methods `textInputDidChange` and `textInputDidChangeSelection` will exit early.
+   *
+   * Setting `_backedTextInputView.attributedText` triggers delegate methods `textInputDidChange` and
+   * `textInputDidChangeSelection` for multiline text input only.
+   * In multiline text input this is undesirable as we don't want to be sending events for changes that JS triggered.
+   */
+  BOOL _comingFromJS;
+  BOOL _didMoveToWindow;
+}
+
+#pragma mark - UIView overrides
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    const auto &defaultProps = TextInputShadowNode::defaultSharedProps();
+    _props = defaultProps;
+
+    _backedTextInputView = defaultProps->traits.multiline ? [RCTUITextView new] : [RCTUITextField new];
+    _backedTextInputView.textInputDelegate = self;
+    _ignoreNextTextInputCall = NO;
+    _comingFromJS = NO;
+    _didMoveToWindow = NO;
+    [self addSubview:_backedTextInputView];
+  }
+
+  return self;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (self.window && !_didMoveToWindow) {
+    const auto &props = static_cast<const TextInputProps &>(*_props);
+    if (props.autoFocus) {
+      [_backedTextInputView becomeFirstResponder];
+    }
+    _didMoveToWindow = YES;
+  }
+  [self _restoreTextSelection];
+}
+
+#pragma mark - RCTViewComponentView overrides
+
+- (NSObject *)accessibilityElement
+{
+  return _backedTextInputView;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<TextInputComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldTextInputProps = static_cast<const TextInputProps &>(*_props);
+  const auto &newTextInputProps = static_cast<const TextInputProps &>(*props);
+
+  // Traits:
+  if (newTextInputProps.traits.multiline != oldTextInputProps.traits.multiline) {
+    [self _setMultiline:newTextInputProps.traits.multiline];
+  }
+
+  if (newTextInputProps.traits.autocapitalizationType != oldTextInputProps.traits.autocapitalizationType) {
+    _backedTextInputView.autocapitalizationType =
+        RCTUITextAutocapitalizationTypeFromAutocapitalizationType(newTextInputProps.traits.autocapitalizationType);
+  }
+
+  if (newTextInputProps.traits.autoCorrect != oldTextInputProps.traits.autoCorrect) {
+    _backedTextInputView.autocorrectionType =
+        RCTUITextAutocorrectionTypeFromOptionalBool(newTextInputProps.traits.autoCorrect);
+  }
+
+  if (newTextInputProps.traits.contextMenuHidden != oldTextInputProps.traits.contextMenuHidden) {
+    _backedTextInputView.contextMenuHidden = newTextInputProps.traits.contextMenuHidden;
+  }
+
+  if (newTextInputProps.traits.editable != oldTextInputProps.traits.editable) {
+    _backedTextInputView.editable = newTextInputProps.traits.editable;
+  }
+
+  if (newTextInputProps.traits.enablesReturnKeyAutomatically !=
+      oldTextInputProps.traits.enablesReturnKeyAutomatically) {
+    _backedTextInputView.enablesReturnKeyAutomatically = newTextInputProps.traits.enablesReturnKeyAutomatically;
+  }
+
+  if (newTextInputProps.traits.keyboardAppearance != oldTextInputProps.traits.keyboardAppearance) {
+    _backedTextInputView.keyboardAppearance =
+        RCTUIKeyboardAppearanceFromKeyboardAppearance(newTextInputProps.traits.keyboardAppearance);
+  }
+
+  if (newTextInputProps.traits.spellCheck != oldTextInputProps.traits.spellCheck) {
+    _backedTextInputView.spellCheckingType =
+        RCTUITextSpellCheckingTypeFromOptionalBool(newTextInputProps.traits.spellCheck);
+  }
+
+  if (newTextInputProps.traits.caretHidden != oldTextInputProps.traits.caretHidden) {
+    _backedTextInputView.caretHidden = newTextInputProps.traits.caretHidden;
+  }
+
+  if (newTextInputProps.traits.clearButtonMode != oldTextInputProps.traits.clearButtonMode) {
+    _backedTextInputView.clearButtonMode =
+        RCTUITextFieldViewModeFromTextInputAccessoryVisibilityMode(newTextInputProps.traits.clearButtonMode);
+  }
+
+  if (newTextInputProps.traits.scrollEnabled != oldTextInputProps.traits.scrollEnabled) {
+    _backedTextInputView.scrollEnabled = newTextInputProps.traits.scrollEnabled;
+  }
+
+  if (newTextInputProps.traits.secureTextEntry != oldTextInputProps.traits.secureTextEntry) {
+    _backedTextInputView.secureTextEntry = newTextInputProps.traits.secureTextEntry;
+  }
+
+  if (newTextInputProps.traits.keyboardType != oldTextInputProps.traits.keyboardType) {
+    _backedTextInputView.keyboardType = RCTUIKeyboardTypeFromKeyboardType(newTextInputProps.traits.keyboardType);
+  }
+
+  if (newTextInputProps.traits.returnKeyType != oldTextInputProps.traits.returnKeyType) {
+    _backedTextInputView.returnKeyType = RCTUIReturnKeyTypeFromReturnKeyType(newTextInputProps.traits.returnKeyType);
+  }
+
+  if (newTextInputProps.traits.textContentType != oldTextInputProps.traits.textContentType) {
+    _backedTextInputView.textContentType = RCTUITextContentTypeFromString(newTextInputProps.traits.textContentType);
+  }
+
+  if (newTextInputProps.traits.passwordRules != oldTextInputProps.traits.passwordRules) {
+    _backedTextInputView.passwordRules = RCTUITextInputPasswordRulesFromString(newTextInputProps.traits.passwordRules);
+  }
+
+  if (newTextInputProps.traits.smartInsertDelete != oldTextInputProps.traits.smartInsertDelete) {
+    _backedTextInputView.smartInsertDeleteType =
+        RCTUITextSmartInsertDeleteTypeFromOptionalBool(newTextInputProps.traits.smartInsertDelete);
+  }
+
+  // Traits `blurOnSubmit`, `clearTextOnFocus`, and `selectTextOnFocus` were omitted intentionally here
+  // because they are being checked on-demand.
+
+  // Other props:
+  if (newTextInputProps.placeholder != oldTextInputProps.placeholder) {
+    _backedTextInputView.placeholder = RCTNSStringFromString(newTextInputProps.placeholder);
+  }
+
+  if (newTextInputProps.placeholderTextColor != oldTextInputProps.placeholderTextColor) {
+    _backedTextInputView.placeholderColor = RCTUIColorFromSharedColor(newTextInputProps.placeholderTextColor);
+  }
+
+  if (newTextInputProps.textAttributes != oldTextInputProps.textAttributes) {
+    _backedTextInputView.defaultTextAttributes =
+        RCTNSTextAttributesFromTextAttributes(newTextInputProps.getEffectiveTextAttributes(RCTFontSizeMultiplier()));
+  }
+
+  if (newTextInputProps.selectionColor != oldTextInputProps.selectionColor) {
+    _backedTextInputView.tintColor = RCTUIColorFromSharedColor(newTextInputProps.selectionColor);
+  }
+
+  if (newTextInputProps.inputAccessoryViewID != oldTextInputProps.inputAccessoryViewID) {
+    _backedTextInputView.inputAccessoryViewID = RCTNSStringFromString(newTextInputProps.inputAccessoryViewID);
+  }
+  [super updateProps:props oldProps:oldProps];
+
+  [self setDefaultInputAccessoryView];
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<TextInputShadowNode::ConcreteState const>(state);
+
+  if (!_state) {
+    assert(false && "State is `null` for <TextInput> component.");
+    _backedTextInputView.attributedText = nil;
+    return;
+  }
+
+  auto data = _state->getData();
+
+  if (!oldState) {
+    _mostRecentEventCount = _state->getData().mostRecentEventCount;
+  }
+
+  if (_mostRecentEventCount == _state->getData().mostRecentEventCount) {
+    _comingFromJS = YES;
+    [self _setAttributedString:RCTNSAttributedStringFromAttributedStringBox(data.attributedStringBox)];
+    _comingFromJS = NO;
+  }
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+
+  _backedTextInputView.frame =
+      UIEdgeInsetsInsetRect(self.bounds, RCTUIEdgeInsetsFromEdgeInsets(layoutMetrics.borderWidth));
+  _backedTextInputView.textContainerInset =
+      RCTUIEdgeInsetsFromEdgeInsets(layoutMetrics.contentInsets - layoutMetrics.borderWidth);
+
+  if (_eventEmitter) {
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onContentSizeChange([self _textInputMetrics]);
+  }
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _state.reset();
+  _backedTextInputView.attributedText = nil;
+  _mostRecentEventCount = 0;
+  _comingFromJS = NO;
+  _lastStringStateWasUpdatedWith = nil;
+  _ignoreNextTextInputCall = NO;
+  _didMoveToWindow = NO;
+  [_backedTextInputView resignFirstResponder];
+}
+
+#pragma mark - RCTBackedTextInputDelegate
+
+- (BOOL)textInputShouldBeginEditing
+{
+  return YES;
+}
+
+- (void)textInputDidBeginEditing
+{
+  const auto &props = static_cast<const TextInputProps &>(*_props);
+
+  if (props.traits.clearTextOnFocus) {
+    _backedTextInputView.attributedText = nil;
+    [self textInputDidChange];
+  }
+
+  if (props.traits.selectTextOnFocus) {
+    [_backedTextInputView selectAll:nil];
+    [self textInputDidChangeSelection];
+  }
+
+  if (_eventEmitter) {
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onFocus([self _textInputMetrics]);
+  }
+}
+
+- (BOOL)textInputShouldEndEditing
+{
+  return YES;
+}
+
+- (void)textInputDidEndEditing
+{
+  if (_eventEmitter) {
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onEndEditing([self _textInputMetrics]);
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onBlur([self _textInputMetrics]);
+  }
+}
+
+- (BOOL)textInputShouldSubmitOnReturn
+{
+  const SubmitBehavior submitBehavior = [self getSubmitBehavior];
+  const BOOL shouldSubmit = submitBehavior == SubmitBehavior::Submit || submitBehavior == SubmitBehavior::BlurAndSubmit;
+  // We send `submit` event here, in `textInputShouldSubmitOnReturn`
+  // (not in `textInputDidReturn)`, because of semantic of the event:
+  // `onSubmitEditing` is called when "Submit" button
+  // (the blue key on onscreen keyboard) did pressed
+  // (no connection to any specific "submitting" process).
+
+  if (_eventEmitter && shouldSubmit) {
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onSubmitEditing([self _textInputMetrics]);
+  }
+  return shouldSubmit;
+}
+
+- (BOOL)textInputShouldReturn
+{
+  return [self getSubmitBehavior] == SubmitBehavior::BlurAndSubmit;
+}
+
+- (void)textInputDidReturn
+{
+  // Does nothing.
+}
+
+- (NSString *)textInputShouldChangeText:(NSString *)text inRange:(NSRange)range
+{
+  const auto &props = static_cast<const TextInputProps &>(*_props);
+
+  if (!_backedTextInputView.textWasPasted) {
+    if (_eventEmitter) {
+      KeyPressMetrics keyPressMetrics;
+      keyPressMetrics.text = RCTStringFromNSString(text);
+      keyPressMetrics.eventCount = _mostRecentEventCount;
+
+      const auto &textInputEventEmitter = static_cast<const TextInputEventEmitter &>(*_eventEmitter);
+      if (props.onKeyPressSync) {
+        textInputEventEmitter.onKeyPressSync(keyPressMetrics);
+      } else {
+        textInputEventEmitter.onKeyPress(keyPressMetrics);
+      }
+    }
+  }
+
+  if (props.maxLength) {
+    NSInteger allowedLength = props.maxLength - _backedTextInputView.attributedText.string.length + range.length;
+
+    if (allowedLength > 0 && text.length > allowedLength) {
+      // make sure unicode characters that are longer than 16 bits (such as emojis) are not cut off
+      NSRange cutOffCharacterRange = [text rangeOfComposedCharacterSequenceAtIndex:allowedLength - 1];
+      if (cutOffCharacterRange.location + cutOffCharacterRange.length > allowedLength) {
+        // the character at the length limit takes more than 16bits, truncation should end at the character before
+        allowedLength = cutOffCharacterRange.location;
+      }
+    }
+
+    if (allowedLength <= 0) {
+      return nil;
+    }
+
+    return allowedLength > text.length ? text : [text substringToIndex:allowedLength];
+  }
+
+  return text;
+}
+
+- (BOOL)textInputShouldChangeTextInRange:(NSRange)range replacementText:(NSString *)text
+{
+  return YES;
+}
+
+- (void)textInputDidChange
+{
+  if (_comingFromJS) {
+    return;
+  }
+
+  if (_ignoreNextTextInputCall && [_lastStringStateWasUpdatedWith isEqual:_backedTextInputView.attributedText]) {
+    _ignoreNextTextInputCall = NO;
+    return;
+  }
+
+  [self _updateState];
+
+  if (_eventEmitter) {
+    const auto &textInputEventEmitter = static_cast<const TextInputEventEmitter &>(*_eventEmitter);
+    const auto &props = static_cast<const TextInputProps &>(*_props);
+    if (props.onChangeSync) {
+      textInputEventEmitter.onChangeSync([self _textInputMetrics]);
+    } else {
+      textInputEventEmitter.onChange([self _textInputMetrics]);
+    }
+  }
+}
+
+- (void)textInputDidChangeSelection
+{
+  if (_comingFromJS) {
+    return;
+  }
+  const auto &props = static_cast<const TextInputProps &>(*_props);
+  if (props.traits.multiline && ![_lastStringStateWasUpdatedWith isEqual:_backedTextInputView.attributedText]) {
+    [self textInputDidChange];
+    _ignoreNextTextInputCall = YES;
+  }
+
+  if (_eventEmitter) {
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onSelectionChange([self _textInputMetrics]);
+  }
+}
+
+#pragma mark - RCTBackedTextInputDelegate (UIScrollViewDelegate)
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+  if (_eventEmitter) {
+    static_cast<const TextInputEventEmitter &>(*_eventEmitter).onScroll([self _textInputMetrics]);
+  }
+}
+
+#pragma mark - Native Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTTextInputHandleCommand(self, commandName, args);
+}
+
+- (void)focus
+{
+  [_backedTextInputView becomeFirstResponder];
+}
+
+- (void)blur
+{
+  [_backedTextInputView resignFirstResponder];
+}
+
+- (void)setTextAndSelection:(NSInteger)eventCount
+                      value:(NSString *__nullable)value
+                      start:(NSInteger)start
+                        end:(NSInteger)end
+{
+  if (_mostRecentEventCount != eventCount) {
+    return;
+  }
+  _comingFromJS = YES;
+  if (value && ![value isEqualToString:_backedTextInputView.attributedText.string]) {
+    NSAttributedString *attributedString =
+        [[NSAttributedString alloc] initWithString:value attributes:_backedTextInputView.defaultTextAttributes];
+    [self _setAttributedString:attributedString];
+    [self _updateState];
+  }
+
+  UITextPosition *startPosition = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument
+                                                                      offset:start];
+  UITextPosition *endPosition = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument
+                                                                    offset:end];
+
+  if (startPosition && endPosition) {
+    UITextRange *range = [_backedTextInputView textRangeFromPosition:startPosition toPosition:endPosition];
+    [_backedTextInputView setSelectedTextRange:range notifyDelegate:NO];
+  }
+  _comingFromJS = NO;
+}
+
+#pragma mark - Default input accessory view
+
+- (void)setDefaultInputAccessoryView
+{
+  // InputAccessoryView component sets the inputAccessoryView when inputAccessoryViewID exists
+  if (_backedTextInputView.inputAccessoryViewID) {
+    if (_backedTextInputView.isFirstResponder) {
+      [_backedTextInputView reloadInputViews];
+    }
+    return;
+  }
+
+  UIKeyboardType keyboardType = _backedTextInputView.keyboardType;
+
+  // These keyboard types (all are number pads) don't have a "Done" button by default,
+  // so we create an `inputAccessoryView` with this button for them.
+  BOOL shouldHaveInputAccessoryView =
+      (keyboardType == UIKeyboardTypeNumberPad || keyboardType == UIKeyboardTypePhonePad ||
+       keyboardType == UIKeyboardTypeDecimalPad || keyboardType == UIKeyboardTypeASCIICapableNumberPad) &&
+      _backedTextInputView.returnKeyType == UIReturnKeyDone;
+
+  if ((_backedTextInputView.inputAccessoryView != nil) == shouldHaveInputAccessoryView) {
+    return;
+  }
+
+  if (shouldHaveInputAccessoryView) {
+    UIToolbar *toolbarView = [UIToolbar new];
+    [toolbarView sizeToFit];
+    UIBarButtonItem *flexibleSpace =
+        [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemFlexibleSpace target:nil action:nil];
+    UIBarButtonItem *doneButton =
+        [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemDone
+                                                      target:self
+                                                      action:@selector(handleInputAccessoryDoneButton)];
+    toolbarView.items = @[ flexibleSpace, doneButton ];
+    _backedTextInputView.inputAccessoryView = toolbarView;
+  } else {
+    _backedTextInputView.inputAccessoryView = nil;
+  }
+
+  if (_backedTextInputView.isFirstResponder) {
+    [_backedTextInputView reloadInputViews];
+  }
+}
+
+- (void)handleInputAccessoryDoneButton
+{
+  if ([self textInputShouldReturn]) {
+    [_backedTextInputView endEditing:YES];
+  }
+}
+
+#pragma mark - Other
+
+- (TextInputMetrics)_textInputMetrics
+{
+  TextInputMetrics metrics;
+  metrics.text = RCTStringFromNSString(_backedTextInputView.attributedText.string);
+  metrics.selectionRange = [self _selectionRange];
+  metrics.eventCount = _mostRecentEventCount;
+
+  CGPoint contentOffset = _backedTextInputView.contentOffset;
+  metrics.contentOffset = {contentOffset.x, contentOffset.y};
+
+  UIEdgeInsets contentInset = _backedTextInputView.contentInset;
+  metrics.contentInset = {contentInset.left, contentInset.top, contentInset.right, contentInset.bottom};
+
+  CGSize contentSize = _backedTextInputView.contentSize;
+  metrics.contentSize = {contentSize.width, contentSize.height};
+
+  CGSize layoutMeasurement = _backedTextInputView.bounds.size;
+  metrics.layoutMeasurement = {layoutMeasurement.width, layoutMeasurement.height};
+
+  CGFloat zoomScale = _backedTextInputView.zoomScale;
+  metrics.zoomScale = zoomScale;
+
+  return metrics;
+}
+
+- (void)_updateState
+{
+  if (!_state) {
+    return;
+  }
+  NSAttributedString *attributedString = _backedTextInputView.attributedText;
+  auto data = _state->getData();
+  _lastStringStateWasUpdatedWith = attributedString;
+  data.attributedStringBox = RCTAttributedStringBoxFromNSAttributedString(attributedString);
+  _mostRecentEventCount += _comingFromJS ? 0 : 1;
+  data.mostRecentEventCount = _mostRecentEventCount;
+  _state->updateState(std::move(data));
+}
+
+- (AttributedString::Range)_selectionRange
+{
+  UITextRange *selectedTextRange = _backedTextInputView.selectedTextRange;
+  NSInteger start = [_backedTextInputView offsetFromPosition:_backedTextInputView.beginningOfDocument
+                                                  toPosition:selectedTextRange.start];
+  NSInteger end = [_backedTextInputView offsetFromPosition:_backedTextInputView.beginningOfDocument
+                                                toPosition:selectedTextRange.end];
+  return AttributedString::Range{(int)start, (int)(end - start)};
+}
+
+- (void)_restoreTextSelection
+{
+  const auto &selection = static_cast<const TextInputProps &>(*_props).selection;
+  if (!selection.has_value()) {
+    return;
+  }
+  auto start = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument
+                                                   offset:selection->start];
+  auto end = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument offset:selection->end];
+  auto range = [_backedTextInputView textRangeFromPosition:start toPosition:end];
+  [_backedTextInputView setSelectedTextRange:range notifyDelegate:YES];
+}
+
+- (void)_setAttributedString:(NSAttributedString *)attributedString
+{
+  if ([self _textOf:attributedString equals:_backedTextInputView.attributedText]) {
+    return;
+  }
+  UITextRange *selectedRange = _backedTextInputView.selectedTextRange;
+  NSInteger oldTextLength = _backedTextInputView.attributedText.string.length;
+  _backedTextInputView.attributedText = attributedString;
+  if (selectedRange.empty) {
+    // Maintaining a cursor position relative to the end of the old text.
+    NSInteger offsetStart = [_backedTextInputView offsetFromPosition:_backedTextInputView.beginningOfDocument
+                                                          toPosition:selectedRange.start];
+    NSInteger offsetFromEnd = oldTextLength - offsetStart;
+    NSInteger newOffset = attributedString.string.length - offsetFromEnd;
+    UITextPosition *position = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument
+                                                                   offset:newOffset];
+    [_backedTextInputView setSelectedTextRange:[_backedTextInputView textRangeFromPosition:position toPosition:position]
+                                notifyDelegate:YES];
+  }
+  [self _restoreTextSelection];
+  _lastStringStateWasUpdatedWith = attributedString;
+}
+
+- (void)_setMultiline:(BOOL)multiline
+{
+  [_backedTextInputView removeFromSuperview];
+  UIView<RCTBackedTextInputViewProtocol> *backedTextInputView = multiline ? [RCTUITextView new] : [RCTUITextField new];
+  backedTextInputView.frame = _backedTextInputView.frame;
+  RCTCopyBackedTextInput(_backedTextInputView, backedTextInputView);
+  _backedTextInputView = backedTextInputView;
+  [self addSubview:_backedTextInputView];
+}
+
+- (BOOL)_textOf:(NSAttributedString *)newText equals:(NSAttributedString *)oldText
+{
+  // When the dictation is running we can't update the attributed text on the backed up text view
+  // because setting the attributed string will kill the dictation. This means that we can't impose
+  // the settings on a dictation.
+  // Similarly, when the user is in the middle of inputting some text in Japanese/Chinese, there will be styling on the
+  // text that we should disregard. See
+  // https://developer.apple.com/documentation/uikit/uitextinput/1614489-markedtextrange?language=objc for more info.
+  // Also, updating the attributed text while inputting Korean language will break input mechanism.
+  // If the user added an emoji, the system adds a font attribute for the emoji and stores the original font in
+  // NSOriginalFont. Lastly, when entering a password, etc., there will be additional styling on the field as the native
+  // text view handles showing the last character for a split second.
+  __block BOOL fontHasBeenUpdatedBySystem = false;
+  [oldText enumerateAttribute:@"NSOriginalFont"
+                      inRange:NSMakeRange(0, oldText.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (value) {
+                       fontHasBeenUpdatedBySystem = true;
+                     }
+                   }];
+
+  BOOL shouldFallbackToBareTextComparison =
+      [_backedTextInputView.textInputMode.primaryLanguage isEqualToString:@"dictation"] ||
+      [_backedTextInputView.textInputMode.primaryLanguage isEqualToString:@"ko-KR"] ||
+      _backedTextInputView.markedTextRange || _backedTextInputView.isSecureTextEntry || fontHasBeenUpdatedBySystem;
+
+  if (shouldFallbackToBareTextComparison) {
+    return ([newText.string isEqualToString:oldText.string]);
+  } else {
+    return ([newText isEqualToAttributedString:oldText]);
+  }
+}
+
+- (SubmitBehavior)getSubmitBehavior
+{
+  const auto &props = static_cast<const TextInputProps &>(*_props);
+  const SubmitBehavior submitBehaviorDefaultable = props.traits.submitBehavior;
+
+  // We should always have a non-default `submitBehavior`, but in case we don't, set it based on multiline.
+  if (submitBehaviorDefaultable == SubmitBehavior::Default) {
+    return props.traits.multiline ? SubmitBehavior::Newline : SubmitBehavior::BlurAndSubmit;
+  }
+
+  return submitBehaviorDefaultable;
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTTextInputCls(void)
+{
+  return RCTTextInputComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputNativeCommands.h

@@ -0,0 +1,104 @@
+/*
+ * 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 <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import <React/RCTLog.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTTextInputViewProtocol <NSObject>
+- (void)focus;
+- (void)blur;
+- (void)setTextAndSelection:(NSInteger)eventCount
+                      value:(NSString *__nullable)value
+                      start:(NSInteger)start
+                        end:(NSInteger)end;
+@end
+
+RCT_EXTERN inline void
+RCTTextInputHandleCommand(id<RCTTextInputViewProtocol> componentView, const NSString *commandName, const NSArray *args)
+{
+  if ([commandName isEqualToString:@"focus"]) {
+#if RCT_DEBUG
+    if ([args count] != 0) {
+      RCTLogError(
+          @"%@ command %@ received %d arguments, expected %d.", @"TextInput", commandName, (int)[args count], 0);
+      return;
+    }
+#endif
+
+    [componentView focus];
+    return;
+  }
+
+  if ([commandName isEqualToString:@"blur"]) {
+#if RCT_DEBUG
+    if ([args count] != 0) {
+      RCTLogError(
+          @"%@ command %@ received %d arguments, expected %d.", @"TextInput", commandName, (int)[args count], 0);
+      return;
+    }
+#endif
+
+    [componentView blur];
+    return;
+  }
+
+  if ([commandName isEqualToString:@"setTextAndSelection"]) {
+#if RCT_DEBUG
+    if ([args count] != 4) {
+      RCTLogError(
+          @"%@ command %@ received %d arguments, expected %d.", @"TextInput", commandName, (int)[args count], 4);
+      return;
+    }
+#endif
+
+    NSObject *arg0 = args[0];
+#if RCT_DEBUG
+    if (!RCTValidateTypeOfViewCommandArgument(arg0, [NSNumber class], @"number", @"TextInput", commandName, @"1st")) {
+      return;
+    }
+#endif
+    NSInteger eventCount = [(NSNumber *)arg0 intValue];
+
+    NSObject *arg1 = args[1];
+#if RCT_DEBUG
+    if (![arg1 isKindOfClass:[NSNull class]] &&
+        !RCTValidateTypeOfViewCommandArgument(arg1, [NSString class], @"string", @"TextInput", commandName, @"2nd")) {
+      return;
+    }
+#endif
+
+    NSString *value = [arg1 isKindOfClass:[NSNull class]] ? nil : (NSString *)arg1;
+
+    NSObject *arg2 = args[2];
+#if RCT_DEBUG
+    if (!RCTValidateTypeOfViewCommandArgument(arg2, [NSNumber class], @"number", @"TextInput", commandName, @"3rd")) {
+      return;
+    }
+#endif
+    NSInteger start = [(NSNumber *)arg2 intValue];
+
+    NSObject *arg3 = args[3];
+#if RCT_DEBUG
+    if (!RCTValidateTypeOfViewCommandArgument(arg3, [NSNumber class], @"number", @"TextInput", commandName, @"4th")) {
+      return;
+    }
+#endif
+    NSInteger end = [(NSNumber *)arg3 intValue];
+
+    [componentView setTextAndSelection:eventCount value:value start:start end:end];
+    return;
+  }
+
+#if RCT_DEBUG
+  RCTLogError(@"%@ received command %@, which is not a supported command.", @"TextInput", commandName);
+#endif
+}
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputUtils.h

@@ -0,0 +1,44 @@
+/*
+ * 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 <optional>
+
+#import <React/RCTBackedTextInputViewProtocol.h>
+#import <react/renderer/components/iostextinput/primitives.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+void RCTCopyBackedTextInput(
+    UIView<RCTBackedTextInputViewProtocol> *fromTextInput,
+    UIView<RCTBackedTextInputViewProtocol> *toTextInput);
+
+UITextAutocorrectionType RCTUITextAutocorrectionTypeFromOptionalBool(std::optional<bool> autoCorrect);
+
+UITextAutocapitalizationType RCTUITextAutocapitalizationTypeFromAutocapitalizationType(
+    facebook::react::AutocapitalizationType autocapitalizationType);
+
+UIKeyboardAppearance RCTUIKeyboardAppearanceFromKeyboardAppearance(
+    facebook::react::KeyboardAppearance keyboardAppearance);
+
+UITextSpellCheckingType RCTUITextSpellCheckingTypeFromOptionalBool(std::optional<bool> spellCheck);
+
+UITextFieldViewMode RCTUITextFieldViewModeFromTextInputAccessoryVisibilityMode(
+    facebook::react::TextInputAccessoryVisibilityMode mode);
+
+UIKeyboardType RCTUIKeyboardTypeFromKeyboardType(facebook::react::KeyboardType keyboardType);
+
+UIReturnKeyType RCTUIReturnKeyTypeFromReturnKeyType(facebook::react::ReturnKeyType returnKeyType);
+
+UITextContentType RCTUITextContentTypeFromString(const std::string &contentType);
+
+UITextInputPasswordRules *RCTUITextInputPasswordRulesFromString(const std::string &passwordRules);
+
+UITextSmartInsertDeleteType RCTUITextSmartInsertDeleteTypeFromOptionalBool(std::optional<bool> smartInsertDelete);
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputUtils.mm

@@ -0,0 +1,253 @@
+/*
+ * 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 "RCTTextInputUtils.h"
+
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+
+static NSAttributedString *RCTSanitizeAttributedString(NSAttributedString *attributedString)
+{
+  // Here we need to remove text attributes specific to particular kind of TextInput on iOS (e.g. limiting line number).
+  // TODO: Implement it properly.
+  return [[NSAttributedString alloc] initWithString:attributedString.string];
+}
+
+void RCTCopyBackedTextInput(
+    UIView<RCTBackedTextInputViewProtocol> *fromTextInput,
+    UIView<RCTBackedTextInputViewProtocol> *toTextInput)
+{
+  toTextInput.attributedText = RCTSanitizeAttributedString(fromTextInput.attributedText);
+  toTextInput.placeholder = fromTextInput.placeholder;
+  toTextInput.placeholderColor = fromTextInput.placeholderColor;
+  toTextInput.textContainerInset = fromTextInput.textContainerInset;
+  toTextInput.inputAccessoryView = fromTextInput.inputAccessoryView;
+  toTextInput.textInputDelegate = fromTextInput.textInputDelegate;
+  toTextInput.placeholderColor = fromTextInput.placeholderColor;
+  toTextInput.defaultTextAttributes = fromTextInput.defaultTextAttributes;
+  toTextInput.autocapitalizationType = fromTextInput.autocapitalizationType;
+  toTextInput.autocorrectionType = fromTextInput.autocorrectionType;
+  toTextInput.contextMenuHidden = fromTextInput.contextMenuHidden;
+  toTextInput.editable = fromTextInput.editable;
+  toTextInput.enablesReturnKeyAutomatically = fromTextInput.enablesReturnKeyAutomatically;
+  toTextInput.keyboardAppearance = fromTextInput.keyboardAppearance;
+  toTextInput.spellCheckingType = fromTextInput.spellCheckingType;
+  toTextInput.caretHidden = fromTextInput.caretHidden;
+  toTextInput.clearButtonMode = fromTextInput.clearButtonMode;
+  toTextInput.scrollEnabled = fromTextInput.scrollEnabled;
+  toTextInput.secureTextEntry = fromTextInput.secureTextEntry;
+  toTextInput.keyboardType = fromTextInput.keyboardType;
+  toTextInput.textContentType = fromTextInput.textContentType;
+  toTextInput.smartInsertDeleteType = fromTextInput.smartInsertDeleteType;
+  toTextInput.passwordRules = fromTextInput.passwordRules;
+
+  [toTextInput setSelectedTextRange:fromTextInput.selectedTextRange notifyDelegate:NO];
+}
+
+UITextAutocorrectionType RCTUITextAutocorrectionTypeFromOptionalBool(std::optional<bool> autoCorrect)
+{
+  return autoCorrect.has_value() ? (*autoCorrect ? UITextAutocorrectionTypeYes : UITextAutocorrectionTypeNo)
+                                 : UITextAutocorrectionTypeDefault;
+}
+
+UITextAutocapitalizationType RCTUITextAutocapitalizationTypeFromAutocapitalizationType(
+    AutocapitalizationType autocapitalizationType)
+{
+  switch (autocapitalizationType) {
+    case AutocapitalizationType::None:
+      return UITextAutocapitalizationTypeNone;
+    case AutocapitalizationType::Words:
+      return UITextAutocapitalizationTypeWords;
+    case AutocapitalizationType::Sentences:
+      return UITextAutocapitalizationTypeSentences;
+    case AutocapitalizationType::Characters:
+      return UITextAutocapitalizationTypeAllCharacters;
+  }
+}
+
+UIKeyboardAppearance RCTUIKeyboardAppearanceFromKeyboardAppearance(KeyboardAppearance keyboardAppearance)
+{
+  switch (keyboardAppearance) {
+    case KeyboardAppearance::Default:
+      return UIKeyboardAppearanceDefault;
+    case KeyboardAppearance::Light:
+      return UIKeyboardAppearanceLight;
+    case KeyboardAppearance::Dark:
+      return UIKeyboardAppearanceDark;
+  }
+}
+
+UITextSpellCheckingType RCTUITextSpellCheckingTypeFromOptionalBool(std::optional<bool> spellCheck)
+{
+  return spellCheck.has_value() ? (*spellCheck ? UITextSpellCheckingTypeYes : UITextSpellCheckingTypeNo)
+                                : UITextSpellCheckingTypeDefault;
+}
+
+UITextFieldViewMode RCTUITextFieldViewModeFromTextInputAccessoryVisibilityMode(
+    facebook::react::TextInputAccessoryVisibilityMode mode)
+{
+  switch (mode) {
+    case TextInputAccessoryVisibilityMode::Never:
+      return UITextFieldViewModeNever;
+    case TextInputAccessoryVisibilityMode::WhileEditing:
+      return UITextFieldViewModeWhileEditing;
+    case TextInputAccessoryVisibilityMode::UnlessEditing:
+      return UITextFieldViewModeUnlessEditing;
+    case TextInputAccessoryVisibilityMode::Always:
+      return UITextFieldViewModeAlways;
+  }
+}
+
+UIKeyboardType RCTUIKeyboardTypeFromKeyboardType(KeyboardType keyboardType)
+{
+  switch (keyboardType) {
+    // Universal
+    case KeyboardType::Default:
+      return UIKeyboardTypeDefault;
+    case KeyboardType::EmailAddress:
+      return UIKeyboardTypeEmailAddress;
+    case KeyboardType::Numeric:
+      return UIKeyboardTypeDecimalPad;
+    case KeyboardType::PhonePad:
+      return UIKeyboardTypePhonePad;
+    case KeyboardType::NumberPad:
+      return UIKeyboardTypeNumberPad;
+    case KeyboardType::DecimalPad:
+      return UIKeyboardTypeDecimalPad;
+    // iOS-only
+    case KeyboardType::ASCIICapable:
+      return UIKeyboardTypeASCIICapable;
+    case KeyboardType::NumbersAndPunctuation:
+      return UIKeyboardTypeNumbersAndPunctuation;
+    case KeyboardType::URL:
+      return UIKeyboardTypeURL;
+    case KeyboardType::NamePhonePad:
+      return UIKeyboardTypeNamePhonePad;
+    case KeyboardType::Twitter:
+      return UIKeyboardTypeTwitter;
+    case KeyboardType::WebSearch:
+      return UIKeyboardTypeWebSearch;
+    case KeyboardType::ASCIICapableNumberPad:
+      return UIKeyboardTypeASCIICapableNumberPad;
+    // Android-only
+    case KeyboardType::VisiblePassword:
+      return UIKeyboardTypeDefault;
+  }
+}
+
+UIReturnKeyType RCTUIReturnKeyTypeFromReturnKeyType(ReturnKeyType returnKeyType)
+{
+  switch (returnKeyType) {
+    case ReturnKeyType::Default:
+      return UIReturnKeyDefault;
+    case ReturnKeyType::Done:
+      return UIReturnKeyDone;
+    case ReturnKeyType::Go:
+      return UIReturnKeyGo;
+    case ReturnKeyType::Next:
+      return UIReturnKeyNext;
+    case ReturnKeyType::Search:
+      return UIReturnKeySearch;
+    case ReturnKeyType::Send:
+      return UIReturnKeySend;
+    // iOS-only
+    case ReturnKeyType::EmergencyCall:
+      return UIReturnKeyEmergencyCall;
+    case ReturnKeyType::Google:
+      return UIReturnKeyGoogle;
+    case ReturnKeyType::Join:
+      return UIReturnKeyJoin;
+    case ReturnKeyType::Route:
+      return UIReturnKeyRoute;
+    case ReturnKeyType::Yahoo:
+      return UIReturnKeyYahoo;
+    case ReturnKeyType::Continue:
+      return UIReturnKeyContinue;
+    // Android-only
+    case ReturnKeyType::None:
+    case ReturnKeyType::Previous:
+      return UIReturnKeyDefault;
+  }
+}
+
+UITextContentType RCTUITextContentTypeFromString(const std::string &contentType)
+{
+  static dispatch_once_t onceToken;
+  static NSDictionary<NSString *, NSString *> *contentTypeMap;
+
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, NSString *> *mutableContentTypeMap = [NSMutableDictionary new];
+    [mutableContentTypeMap addEntriesFromDictionary:@{
+      @"" : @"",
+      @"none" : @"",
+      @"URL" : UITextContentTypeURL,
+      @"addressCity" : UITextContentTypeAddressCity,
+      @"addressCityAndState" : UITextContentTypeAddressCityAndState,
+      @"addressState" : UITextContentTypeAddressState,
+      @"countryName" : UITextContentTypeCountryName,
+      @"creditCardNumber" : UITextContentTypeCreditCardNumber,
+      @"emailAddress" : UITextContentTypeEmailAddress,
+      @"familyName" : UITextContentTypeFamilyName,
+      @"fullStreetAddress" : UITextContentTypeFullStreetAddress,
+      @"givenName" : UITextContentTypeGivenName,
+      @"jobTitle" : UITextContentTypeJobTitle,
+      @"location" : UITextContentTypeLocation,
+      @"middleName" : UITextContentTypeMiddleName,
+      @"name" : UITextContentTypeName,
+      @"namePrefix" : UITextContentTypeNamePrefix,
+      @"nameSuffix" : UITextContentTypeNameSuffix,
+      @"nickname" : UITextContentTypeNickname,
+      @"organizationName" : UITextContentTypeOrganizationName,
+      @"postalCode" : UITextContentTypePostalCode,
+      @"streetAddressLine1" : UITextContentTypeStreetAddressLine1,
+      @"streetAddressLine2" : UITextContentTypeStreetAddressLine2,
+      @"sublocality" : UITextContentTypeSublocality,
+      @"telephoneNumber" : UITextContentTypeTelephoneNumber,
+      @"username" : UITextContentTypeUsername,
+      @"password" : UITextContentTypePassword,
+      @"newPassword" : UITextContentTypeNewPassword,
+      @"oneTimeCode" : UITextContentTypeOneTimeCode,
+    }];
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000 /* __IPHONE_17_0 */
+    if (@available(iOS 17.0, *)) {
+      [mutableContentTypeMap addEntriesFromDictionary:@{
+        @"creditCardExpiration" : UITextContentTypeCreditCardExpiration,
+        @"creditCardExpirationMonth" : UITextContentTypeCreditCardExpirationMonth,
+        @"creditCardExpirationYear" : UITextContentTypeCreditCardExpirationYear,
+        @"creditCardSecurityCode" : UITextContentTypeCreditCardSecurityCode,
+        @"creditCardType" : UITextContentTypeCreditCardType,
+        @"creditCardName" : UITextContentTypeCreditCardName,
+        @"creditCardGivenName" : UITextContentTypeCreditCardGivenName,
+        @"creditCardMiddleName" : UITextContentTypeCreditCardMiddleName,
+        @"creditCardFamilyName" : UITextContentTypeCreditCardFamilyName,
+        @"birthdate" : UITextContentTypeBirthdate,
+        @"birthdateDay" : UITextContentTypeBirthdateDay,
+        @"birthdateMonth" : UITextContentTypeBirthdateMonth,
+        @"birthdateYear" : UITextContentTypeBirthdateYear,
+      }];
+    }
+#endif
+
+    contentTypeMap = mutableContentTypeMap;
+  });
+
+  return contentTypeMap[RCTNSStringFromString(contentType)] ?: @"";
+}
+
+UITextInputPasswordRules *RCTUITextInputPasswordRulesFromString(const std::string &passwordRules)
+{
+  return [UITextInputPasswordRules passwordRulesWithDescriptor:RCTNSStringFromStringNilIfEmpty(passwordRules)];
+}
+
+UITextSmartInsertDeleteType RCTUITextSmartInsertDeleteTypeFromOptionalBool(std::optional<bool> smartInsertDelete)
+{
+  return smartInsertDelete.has_value()
+      ? (*smartInsertDelete ? UITextSmartInsertDeleteTypeYes : UITextSmartInsertDeleteTypeNo)
+      : UITextSmartInsertDeleteTypeDefault;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/UnimplementedComponent/RCTUnimplementedNativeComponentView.h

@@ -0,0 +1,18 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTUnimplementedNativeComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/UnimplementedComponent/RCTUnimplementedNativeComponentView.mm

@@ -0,0 +1,59 @@
+/*
+ * 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 "RCTUnimplementedNativeComponentView.h"
+
+#import <react/renderer/components/rncore/ComponentDescriptors.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+
+using namespace facebook::react;
+
+@implementation RCTUnimplementedNativeComponentView {
+  UILabel *_label;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = UnimplementedNativeViewShadowNode::defaultSharedProps();
+
+    CGRect bounds = self.bounds;
+    _label = [[UILabel alloc] initWithFrame:bounds];
+    _label.backgroundColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.3];
+    _label.layoutMargins = UIEdgeInsetsMake(12, 12, 12, 12);
+    _label.lineBreakMode = NSLineBreakByWordWrapping;
+    _label.numberOfLines = 0;
+    _label.textAlignment = NSTextAlignmentCenter;
+    _label.textColor = [UIColor whiteColor];
+
+    self.contentView = _label;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<UnimplementedNativeViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps = static_cast<const UnimplementedNativeViewProps &>(*_props);
+  const auto &newViewProps = static_cast<const UnimplementedNativeViewProps &>(*props);
+
+  if (oldViewProps.name != newViewProps.name) {
+    _label.text = [NSString stringWithFormat:@"'%s' is not Fabric compatible yet.", newViewProps.name.c_str()];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/UnimplementedView/RCTUnimplementedViewComponentView.h

@@ -0,0 +1,21 @@
+/*
+ * 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/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * UIView class for all kinds of <UnimplementedView> components.
+ */
+@interface RCTUnimplementedViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/UnimplementedView/RCTUnimplementedViewComponentView.mm

@@ -0,0 +1,72 @@
+/*
+ * 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 "RCTUnimplementedViewComponentView.h"
+
+#import <react/renderer/components/rncore/ComponentDescriptors.h>
+#import <react/renderer/components/rncore/EventEmitters.h>
+#import <react/renderer/components/rncore/Props.h>
+
+#import <react/renderer/components/unimplementedview/UnimplementedViewComponentDescriptor.h>
+#import <react/renderer/components/unimplementedview/UnimplementedViewShadowNode.h>
+
+#import <React/RCTConversions.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@implementation RCTUnimplementedViewComponentView {
+  UILabel *_label;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = UnimplementedViewShadowNode::defaultSharedProps();
+
+    _label = [[UILabel alloc] initWithFrame:self.bounds];
+    _label.backgroundColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.3];
+    _label.lineBreakMode = NSLineBreakByCharWrapping;
+    _label.numberOfLines = 0;
+    _label.textAlignment = NSTextAlignmentCenter;
+    _label.textColor = [UIColor whiteColor];
+    _label.allowsDefaultTighteningForTruncation = YES;
+    _label.adjustsFontSizeToFitWidth = YES;
+
+    self.contentView = _label;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<UnimplementedViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldUnimplementedViewProps = static_cast<const UnimplementedViewProps &>(*_props);
+  const auto &newUnimplementedViewProps = static_cast<const UnimplementedViewProps &>(*props);
+
+  if (oldUnimplementedViewProps.getComponentName() != newUnimplementedViewProps.getComponentName()) {
+    _label.text =
+        [NSString stringWithFormat:@"Unimplemented component: <%s>", newUnimplementedViewProps.getComponentName()];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RCTUnimplementedNativeViewCls(void)
+{
+  return RCTUnimplementedViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.h

@@ -0,0 +1,85 @@
+/*
+ * 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/RCTComponentViewProtocol.h>
+#import <React/RCTConstants.h>
+#import <React/RCTTouchableComponentViewProtocol.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <react/renderer/components/view/ViewEventEmitter.h>
+#import <react/renderer/components/view/ViewProps.h>
+#import <react/renderer/core/EventEmitter.h>
+#import <react/renderer/core/LayoutMetrics.h>
+#import <react/renderer/core/Props.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView class for <View> component.
+ */
+@interface RCTViewComponentView : UIView <RCTComponentViewProtocol, RCTTouchableComponentViewProtocol> {
+ @protected
+  facebook::react::LayoutMetrics _layoutMetrics;
+  facebook::react::SharedViewProps _props;
+  facebook::react::SharedViewEventEmitter _eventEmitter;
+}
+
+/**
+ * Represents the `UIView` instance that is being automatically attached to
+ * the component view and laid out using on `layoutMetrics` (especially `size`
+ * and `padding`) of the component.
+ * This view must not be a component view; it's just a convenient way
+ * to embed/bridge pure native views as component views.
+ * Defaults to `nil`. Assign `nil` to remove view as subview.
+ */
+@property (nonatomic, strong, nullable) UIView *contentView;
+
+/**
+ * Provides access to `nativeId` prop of the component.
+ * It might be used by subclasses (which need to refer to the view from
+ * other platform-specific external views or systems by some id) or
+ * by debugging/inspection tools.
+ * Defaults to `nil`.
+ */
+@property (nonatomic, strong, nullable) NSString *nativeId;
+
+/**
+ * Returns the object - usually (sub)view - which represents this
+ * component view in terms of accessibility.
+ * All accessibility properties will be applied to this object.
+ * May be overridden in subclass which needs to be accessiblitywise
+ * transparent in favour of some subview.
+ * Defaults to `self`.
+ */
+@property (nonatomic, strong, nullable, readonly) NSObject *accessibilityElement;
+
+/**
+ * Insets used when hit testing inside this view.
+ */
+@property (nonatomic, assign) UIEdgeInsets hitTestEdgeInsets;
+
+/**
+ * Enforcing `call super` semantic for overridden methods from `RCTComponentViewProtocol`.
+ * The methods update the instance variables.
+ */
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps NS_REQUIRES_SUPER;
+- (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventEmitter NS_REQUIRES_SUPER;
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics NS_REQUIRES_SUPER;
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask NS_REQUIRES_SUPER;
+- (void)prepareForRecycle NS_REQUIRES_SUPER;
+
+/*
+ * This is a fragment of temporary workaround that we need only temporary and will get rid of soon.
+ */
+- (NSString *)componentViewName_DO_NOT_USE_THIS_IS_BROKEN;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -0,0 +1,929 @@
+/*
+ * 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 "RCTViewComponentView.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <QuartzCore/QuartzCore.h>
+#import <objc/runtime.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTBorderDrawing.h>
+#import <React/RCTConversions.h>
+#import <React/RCTLocalizedString.h>
+#import <react/renderer/components/view/ViewComponentDescriptor.h>
+#import <react/renderer/components/view/ViewEventEmitter.h>
+#import <react/renderer/components/view/ViewProps.h>
+#import <react/renderer/components/view/accessibilityPropsConversions.h>
+
+#ifdef RCT_DYNAMIC_FRAMEWORKS
+#import <React/RCTComponentViewFactory.h>
+#endif
+
+using namespace facebook::react;
+
+@implementation RCTViewComponentView {
+  UIColor *_backgroundColor;
+  __weak CALayer *_borderLayer;
+  BOOL _needsInvalidateLayer;
+  BOOL _isJSResponder;
+  BOOL _removeClippedSubviews;
+  NSMutableArray<UIView *> *_reactSubviews;
+  NSSet<NSString *> *_Nullable _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
+}
+
+#ifdef RCT_DYNAMIC_FRAMEWORKS
++ (void)load
+{
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:self];
+}
+#endif
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = ViewShadowNode::defaultSharedProps();
+    _reactSubviews = [NSMutableArray new];
+    self.multipleTouchEnabled = YES;
+  }
+  return self;
+}
+
+- (facebook::react::Props::Shared)props
+{
+  return _props;
+}
+
+- (void)setContentView:(UIView *)contentView
+{
+  if (_contentView) {
+    [_contentView removeFromSuperview];
+  }
+
+  _contentView = contentView;
+
+  if (_contentView) {
+    [self addSubview:_contentView];
+    _contentView.frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+  }
+}
+
+- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
+{
+  if (UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero)) {
+    return [super pointInside:point withEvent:event];
+  }
+  CGRect hitFrame = UIEdgeInsetsInsetRect(self.bounds, self.hitTestEdgeInsets);
+  return CGRectContainsPoint(hitFrame, point);
+}
+
+- (UIColor *)backgroundColor
+{
+  return _backgroundColor;
+}
+
+- (void)setBackgroundColor:(UIColor *)backgroundColor
+{
+  _backgroundColor = backgroundColor;
+}
+
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection
+{
+  [super traitCollectionDidChange:previousTraitCollection];
+
+  if ([self.traitCollection hasDifferentColorAppearanceComparedToTraitCollection:previousTraitCollection]) {
+    [self invalidateLayer];
+  }
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  RCTAssert(
+      self == [RCTViewComponentView class],
+      @"`+[RCTComponentViewProtocol componentDescriptorProvider]` must be implemented for all subclasses (and `%@` particularly).",
+      NSStringFromClass([self class]));
+  return concreteComponentDescriptorProvider<ViewComponentDescriptor>();
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      childComponentView.superview == nil,
+      @"Attempt to mount already mounted component view. (parent: %@, child: %@, index: %@, existing parent: %@)",
+      self,
+      childComponentView,
+      @(index),
+      @([childComponentView.superview tag]));
+
+  if (_removeClippedSubviews) {
+    [_reactSubviews insertObject:childComponentView atIndex:index];
+  } else {
+    [self insertSubview:childComponentView atIndex:index];
+  }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  if (_removeClippedSubviews) {
+    [_reactSubviews removeObjectAtIndex:index];
+  } else {
+    RCTAssert(
+        childComponentView.superview == self,
+        @"Attempt to unmount a view which is mounted inside different view. (parent: %@, child: %@, index: %@)",
+        self,
+        childComponentView,
+        @(index));
+    RCTAssert(
+        (self.subviews.count > index) && [self.subviews objectAtIndex:index] == childComponentView,
+        @"Attempt to unmount a view which has a different index. (parent: %@, child: %@, index: %@, actual index: %@, tag at index: %@)",
+        self,
+        childComponentView,
+        @(index),
+        @([self.subviews indexOfObject:childComponentView]),
+        @([[self.subviews objectAtIndex:index] tag]));
+  }
+
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
+{
+  if (!_removeClippedSubviews) {
+    // Use default behavior if unmounting is disabled
+    return [super updateClippedSubviewsWithClipRect:clipRect relativeToView:clipView];
+  }
+
+  if (_reactSubviews.count == 0) {
+    // Do nothing if we have no subviews
+    return;
+  }
+
+  if (CGSizeEqualToSize(self.bounds.size, CGSizeZero)) {
+    // Do nothing if layout hasn't happened yet
+    return;
+  }
+
+  // Convert clipping rect to local coordinates
+  clipRect = [clipView convertRect:clipRect toView:self];
+
+  // Mount / unmount views
+  for (UIView *view in _reactSubviews) {
+    if (CGRectIntersectsRect(clipRect, view.frame)) {
+      // View is at least partially visible, so remount it if unmounted
+      [self addSubview:view];
+      // View is visible, update clipped subviews
+      [view updateClippedSubviewsWithClipRect:clipRect relativeToView:self];
+    } else if (view.superview) {
+      // View is completely outside the clipRect, so unmount it
+      [view removeFromSuperview];
+    }
+  }
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  RCTAssert(props, @"`props` must not be `null`.");
+
+#ifndef NS_BLOCK_ASSERTIONS
+  auto propsRawPtr = _props.get();
+  RCTAssert(
+      propsRawPtr &&
+          ([self class] == [RCTViewComponentView class] ||
+           typeid(*propsRawPtr).hash_code() != typeid(ViewProps const).hash_code()),
+      @"`RCTViewComponentView` subclasses (and `%@` particularly) must setup `_props`"
+       " instance variable with a default value in the constructor.",
+      NSStringFromClass([self class]));
+#endif
+
+  const auto &oldViewProps = static_cast<const ViewProps &>(*_props);
+  const auto &newViewProps = static_cast<const ViewProps &>(*props);
+
+  BOOL needsInvalidateLayer = NO;
+
+  // `opacity`
+  if (oldViewProps.opacity != newViewProps.opacity &&
+      ![_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"opacity"]) {
+    self.layer.opacity = (float)newViewProps.opacity;
+    needsInvalidateLayer = YES;
+  }
+
+  if (oldViewProps.removeClippedSubviews != newViewProps.removeClippedSubviews) {
+    _removeClippedSubviews = newViewProps.removeClippedSubviews;
+    if (_removeClippedSubviews && self.subviews.count > 0) {
+      _reactSubviews = [NSMutableArray arrayWithArray:self.subviews];
+    }
+  }
+
+  // `backgroundColor`
+  if (oldViewProps.backgroundColor != newViewProps.backgroundColor) {
+    self.backgroundColor = RCTUIColorFromSharedColor(newViewProps.backgroundColor);
+    needsInvalidateLayer = YES;
+  }
+
+  // `shadowColor`
+  if (oldViewProps.shadowColor != newViewProps.shadowColor) {
+    CGColorRef shadowColor = RCTCreateCGColorRefFromSharedColor(newViewProps.shadowColor);
+    self.layer.shadowColor = shadowColor;
+    CGColorRelease(shadowColor);
+    needsInvalidateLayer = YES;
+  }
+
+  // `shadowOffset`
+  if (oldViewProps.shadowOffset != newViewProps.shadowOffset) {
+    self.layer.shadowOffset = RCTCGSizeFromSize(newViewProps.shadowOffset);
+    needsInvalidateLayer = YES;
+  }
+
+  // `shadowOpacity`
+  if (oldViewProps.shadowOpacity != newViewProps.shadowOpacity) {
+    self.layer.shadowOpacity = (float)newViewProps.shadowOpacity;
+    needsInvalidateLayer = YES;
+  }
+
+  // `shadowRadius`
+  if (oldViewProps.shadowRadius != newViewProps.shadowRadius) {
+    self.layer.shadowRadius = (CGFloat)newViewProps.shadowRadius;
+    needsInvalidateLayer = YES;
+  }
+
+  // `backfaceVisibility`
+  if (oldViewProps.backfaceVisibility != newViewProps.backfaceVisibility) {
+    self.layer.doubleSided = newViewProps.backfaceVisibility == BackfaceVisibility::Visible;
+  }
+
+  // `cursor`
+  if (oldViewProps.cursor != newViewProps.cursor) {
+    needsInvalidateLayer = YES;
+  }
+
+  // `shouldRasterize`
+  if (oldViewProps.shouldRasterize != newViewProps.shouldRasterize) {
+    self.layer.shouldRasterize = newViewProps.shouldRasterize;
+    self.layer.rasterizationScale = newViewProps.shouldRasterize ? self.traitCollection.displayScale : 1.0;
+  }
+
+  // `pointerEvents`
+  if (oldViewProps.pointerEvents != newViewProps.pointerEvents) {
+    self.userInteractionEnabled = newViewProps.pointerEvents != PointerEventsMode::None;
+  }
+
+  // `transform`
+  if ((oldViewProps.transform != newViewProps.transform ||
+       oldViewProps.transformOrigin != newViewProps.transformOrigin) &&
+      ![_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"transform"]) {
+    auto newTransform = newViewProps.resolveTransform(_layoutMetrics);
+    CATransform3D caTransform = RCTCATransform3DFromTransformMatrix(newTransform);
+
+    self.layer.transform = caTransform;
+    // Enable edge antialiasing in rotation, skew, or perspective transforms
+    self.layer.allowsEdgeAntialiasing = caTransform.m12 != 0.0f || caTransform.m21 != 0.0f || caTransform.m34 != 0.0f;
+  }
+
+  // `hitSlop`
+  if (oldViewProps.hitSlop != newViewProps.hitSlop) {
+    self.hitTestEdgeInsets = {
+        -newViewProps.hitSlop.top,
+        -newViewProps.hitSlop.left,
+        -newViewProps.hitSlop.bottom,
+        -newViewProps.hitSlop.right};
+  }
+
+  // `overflow`
+  if (oldViewProps.getClipsContentToBounds() != newViewProps.getClipsContentToBounds()) {
+    self.clipsToBounds = newViewProps.getClipsContentToBounds();
+    needsInvalidateLayer = YES;
+  }
+
+  // `border`
+  if (oldViewProps.borderStyles != newViewProps.borderStyles || oldViewProps.borderRadii != newViewProps.borderRadii ||
+      oldViewProps.borderColors != newViewProps.borderColors) {
+    needsInvalidateLayer = YES;
+  }
+
+  // `nativeId`
+  if (oldViewProps.nativeId != newViewProps.nativeId) {
+    self.nativeId = RCTNSStringFromStringNilIfEmpty(newViewProps.nativeId);
+  }
+
+  // `accessible`
+  if (oldViewProps.accessible != newViewProps.accessible) {
+    self.accessibilityElement.isAccessibilityElement = newViewProps.accessible;
+  }
+
+  // `accessibilityLabel`
+  if (oldViewProps.accessibilityLabel != newViewProps.accessibilityLabel) {
+    self.accessibilityElement.accessibilityLabel = RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityLabel);
+  }
+
+  // `accessibilityLanguage`
+  if (oldViewProps.accessibilityLanguage != newViewProps.accessibilityLanguage) {
+    self.accessibilityElement.accessibilityLanguage =
+        RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityLanguage);
+  }
+
+  // `accessibilityHint`
+  if (oldViewProps.accessibilityHint != newViewProps.accessibilityHint) {
+    self.accessibilityElement.accessibilityHint = RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityHint);
+  }
+
+  // `accessibilityViewIsModal`
+  if (oldViewProps.accessibilityViewIsModal != newViewProps.accessibilityViewIsModal) {
+    self.accessibilityElement.accessibilityViewIsModal = newViewProps.accessibilityViewIsModal;
+  }
+
+  // `accessibilityElementsHidden`
+  if (oldViewProps.accessibilityElementsHidden != newViewProps.accessibilityElementsHidden) {
+    self.accessibilityElement.accessibilityElementsHidden = newViewProps.accessibilityElementsHidden;
+  }
+
+  // `accessibilityTraits`
+  if (oldViewProps.accessibilityTraits != newViewProps.accessibilityTraits) {
+    self.accessibilityElement.accessibilityTraits =
+        RCTUIAccessibilityTraitsFromAccessibilityTraits(newViewProps.accessibilityTraits);
+  }
+
+  // `accessibilityState`
+  if (oldViewProps.accessibilityState != newViewProps.accessibilityState) {
+    self.accessibilityTraits &= ~(UIAccessibilityTraitNotEnabled | UIAccessibilityTraitSelected);
+    const auto accessibilityState = newViewProps.accessibilityState.value_or(AccessibilityState{});
+    if (accessibilityState.selected) {
+      self.accessibilityTraits |= UIAccessibilityTraitSelected;
+    }
+    if (accessibilityState.disabled) {
+      self.accessibilityTraits |= UIAccessibilityTraitNotEnabled;
+    }
+  }
+
+  // `accessibilityIgnoresInvertColors`
+  if (oldViewProps.accessibilityIgnoresInvertColors != newViewProps.accessibilityIgnoresInvertColors) {
+    self.accessibilityIgnoresInvertColors = newViewProps.accessibilityIgnoresInvertColors;
+  }
+
+  // `accessibilityValue`
+  if (oldViewProps.accessibilityValue != newViewProps.accessibilityValue) {
+    if (newViewProps.accessibilityValue.text.has_value()) {
+      self.accessibilityElement.accessibilityValue =
+          RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityValue.text.value());
+    } else if (
+        newViewProps.accessibilityValue.now.has_value() && newViewProps.accessibilityValue.min.has_value() &&
+        newViewProps.accessibilityValue.max.has_value()) {
+      CGFloat val = (CGFloat)(newViewProps.accessibilityValue.now.value()) /
+          (newViewProps.accessibilityValue.max.value() - newViewProps.accessibilityValue.min.value());
+      self.accessibilityElement.accessibilityValue =
+          [NSNumberFormatter localizedStringFromNumber:@(val) numberStyle:NSNumberFormatterPercentStyle];
+      ;
+    } else {
+      self.accessibilityElement.accessibilityValue = nil;
+    }
+  }
+
+  // `testId`
+  if (oldViewProps.testId != newViewProps.testId) {
+    self.accessibilityIdentifier = RCTNSStringFromString(newViewProps.testId);
+  }
+
+  _needsInvalidateLayer = _needsInvalidateLayer || needsInvalidateLayer;
+
+  _props = std::static_pointer_cast<const ViewProps>(props);
+}
+
+- (void)updateEventEmitter:(const EventEmitter::Shared &)eventEmitter
+{
+  assert(std::dynamic_pointer_cast<const ViewEventEmitter>(eventEmitter));
+  _eventEmitter = std::static_pointer_cast<const ViewEventEmitter>(eventEmitter);
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  // Using stored `_layoutMetrics` as `oldLayoutMetrics` here to avoid
+  // re-applying individual sub-values which weren't changed.
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:_layoutMetrics];
+
+  _layoutMetrics = layoutMetrics;
+  _needsInvalidateLayer = YES;
+
+  _borderLayer.frame = self.layer.bounds;
+
+  if (_contentView) {
+    _contentView.frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+  }
+
+  if (_props->transformOrigin.isSet()) {
+    auto newTransform = _props->resolveTransform(layoutMetrics);
+    self.layer.transform = RCTCATransform3DFromTransformMatrix(newTransform);
+  }
+}
+
+- (BOOL)isJSResponder
+{
+  return _isJSResponder;
+}
+
+- (void)setIsJSResponder:(BOOL)isJSResponder
+{
+  _isJSResponder = isJSResponder;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
+{
+  [super finalizeUpdates:updateMask];
+  if (!_needsInvalidateLayer) {
+    return;
+  }
+
+  _needsInvalidateLayer = NO;
+  [self invalidateLayer];
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+
+  // If view was managed by animated, its props need to align with UIView's properties.
+  const auto &props = static_cast<const ViewProps &>(*_props);
+  if ([_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"transform"]) {
+    self.layer.transform = RCTCATransform3DFromTransformMatrix(props.transform);
+  }
+  if ([_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"opacity"]) {
+    self.layer.opacity = (float)props.opacity;
+  }
+
+  _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = nil;
+  _eventEmitter.reset();
+  _isJSResponder = NO;
+  _removeClippedSubviews = NO;
+  _reactSubviews = [NSMutableArray new];
+}
+
+- (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(NSSet<NSString *> *_Nullable)props
+{
+  _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = props;
+}
+
+- (NSSet<NSString *> *_Nullable)propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN
+{
+  return _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
+}
+
+- (UIView *)betterHitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  // This is a classic textbook implementation of `hitTest:` with a couple of improvements:
+  //   * It does not stop algorithm if some touch is outside the view
+  //     which does not have `clipToBounds` enabled.
+  //   * Taking `layer.zIndex` field into an account is not required because
+  //     lists of `ShadowView`s are already sorted based on `zIndex` prop.
+
+  if (!self.userInteractionEnabled || self.hidden || self.alpha < 0.01) {
+    return nil;
+  }
+
+  BOOL isPointInside = [self pointInside:point withEvent:event];
+
+  BOOL clipsToBounds = self.clipsToBounds;
+
+  clipsToBounds = clipsToBounds || _layoutMetrics.overflowInset == EdgeInsets{};
+
+  if (clipsToBounds && !isPointInside) {
+    return nil;
+  }
+
+  for (UIView *subview in [self.subviews reverseObjectEnumerator]) {
+    UIView *hitView = [subview hitTest:[subview convertPoint:point fromView:self] withEvent:event];
+    if (hitView) {
+      return hitView;
+    }
+  }
+
+  return isPointInside ? self : nil;
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  switch (_props->pointerEvents) {
+    case PointerEventsMode::Auto:
+      return [self betterHitTest:point withEvent:event];
+    case PointerEventsMode::None:
+      return nil;
+    case PointerEventsMode::BoxOnly:
+      return [self pointInside:point withEvent:event] ? self : nil;
+    case PointerEventsMode::BoxNone:
+      UIView *view = [self betterHitTest:point withEvent:event];
+      return view != self ? view : nil;
+  }
+}
+
+static RCTCornerRadii RCTCornerRadiiFromBorderRadii(BorderRadii borderRadii)
+{
+  return RCTCornerRadii{
+      .topLeft = (CGFloat)borderRadii.topLeft,
+      .topRight = (CGFloat)borderRadii.topRight,
+      .bottomLeft = (CGFloat)borderRadii.bottomLeft,
+      .bottomRight = (CGFloat)borderRadii.bottomRight};
+}
+
+static RCTBorderColors RCTCreateRCTBorderColorsFromBorderColors(BorderColors borderColors)
+{
+  return RCTBorderColors{
+      .top = RCTCreateCGColorRefFromSharedColor(borderColors.top),
+      .left = RCTCreateCGColorRefFromSharedColor(borderColors.left),
+      .bottom = RCTCreateCGColorRefFromSharedColor(borderColors.bottom),
+      .right = RCTCreateCGColorRefFromSharedColor(borderColors.right)};
+}
+
+static void RCTReleaseRCTBorderColors(RCTBorderColors borderColors)
+{
+  CGColorRelease(borderColors.top);
+  CGColorRelease(borderColors.left);
+  CGColorRelease(borderColors.bottom);
+  CGColorRelease(borderColors.right);
+}
+
+static CALayerCornerCurve CornerCurveFromBorderCurve(BorderCurve borderCurve)
+{
+  // The constants are available only starting from iOS 13
+  // CALayerCornerCurve is a typealias on NSString *
+  switch (borderCurve) {
+    case BorderCurve::Continuous:
+      return @"continuous"; // kCACornerCurveContinuous;
+    case BorderCurve::Circular:
+      return @"circular"; // kCACornerCurveCircular;
+  }
+}
+
+static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
+{
+  switch (borderStyle) {
+    case BorderStyle::Solid:
+      return RCTBorderStyleSolid;
+    case BorderStyle::Dotted:
+      return RCTBorderStyleDotted;
+    case BorderStyle::Dashed:
+      return RCTBorderStyleDashed;
+  }
+}
+
+- (void)invalidateLayer
+{
+  CALayer *layer = self.layer;
+
+  if (CGSizeEqualToSize(layer.bounds.size, CGSizeZero)) {
+    return;
+  }
+
+  const auto borderMetrics = _props->resolveBorderMetrics(_layoutMetrics);
+
+  // Stage 1. Shadow Path
+  BOOL const layerHasShadow = layer.shadowOpacity > 0 && CGColorGetAlpha(layer.shadowColor) > 0;
+  if (layerHasShadow) {
+    if (CGColorGetAlpha(_backgroundColor.CGColor) > 0.999) {
+      // If view has a solid background color, calculate shadow path from border.
+      const RCTCornerInsets cornerInsets =
+          RCTGetCornerInsets(RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero);
+      CGPathRef shadowPath = RCTPathCreateWithRoundedRect(self.bounds, cornerInsets, nil);
+      layer.shadowPath = shadowPath;
+      CGPathRelease(shadowPath);
+    } else {
+      // Can't accurately calculate box shadow, so fall back to pixel-based shadow.
+      layer.shadowPath = nil;
+    }
+  } else {
+    layer.shadowPath = nil;
+  }
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000 /* __IPHONE_17_0 */
+  // Stage 1.5. Cursor / Hover Effects
+  if (@available(iOS 17.0, *)) {
+    UIHoverStyle *hoverStyle = nil;
+    if (_props->cursor == Cursor::Pointer) {
+      const RCTCornerInsets cornerInsets =
+          RCTGetCornerInsets(RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero);
+#if TARGET_OS_IOS
+      // Due to an Apple bug, it seems on iOS, UIShapes made with `[UIShape shapeWithBezierPath:]`
+      // evaluate their shape on the superviews' coordinate space. This leads to the hover shape
+      // rendering incorrectly on iOS, iOS apps in compatibility mode on visionOS, but not on visionOS.
+      // To work around this, for iOS, we can calculate the border path based on `view.frame` (the
+      // superview's coordinate space) instead of view.bounds.
+      CGPathRef borderPath = RCTPathCreateWithRoundedRect(self.frame, cornerInsets, NULL);
+#else // TARGET_OS_VISION
+      CGPathRef borderPath = RCTPathCreateWithRoundedRect(self.bounds, cornerInsets, NULL);
+#endif
+      UIBezierPath *bezierPath = [UIBezierPath bezierPathWithCGPath:borderPath];
+      CGPathRelease(borderPath);
+      UIShape *shape = [UIShape shapeWithBezierPath:bezierPath];
+
+      hoverStyle = [UIHoverStyle styleWithEffect:[UIHoverAutomaticEffect effect] shape:shape];
+    }
+    [self setHoverStyle:hoverStyle];
+  }
+#endif
+
+  // Stage 2. Border Rendering
+  const bool useCoreAnimationBorderRendering =
+      borderMetrics.borderColors.isUniform() && borderMetrics.borderWidths.isUniform() &&
+      borderMetrics.borderStyles.isUniform() && borderMetrics.borderRadii.isUniform() &&
+      borderMetrics.borderStyles.left == BorderStyle::Solid &&
+      (
+          // iOS draws borders in front of the content whereas CSS draws them behind
+          // the content. For this reason, only use iOS border drawing when clipping
+          // or when the border is hidden.
+          borderMetrics.borderWidths.left == 0 ||
+          colorComponentsFromColor(borderMetrics.borderColors.left).alpha == 0 || self.clipsToBounds);
+
+  CGColorRef backgroundColor = [_backgroundColor resolvedColorWithTraitCollection:self.traitCollection].CGColor;
+
+  if (useCoreAnimationBorderRendering) {
+    layer.mask = nil;
+    [_borderLayer removeFromSuperlayer];
+
+    layer.borderWidth = (CGFloat)borderMetrics.borderWidths.left;
+    CGColorRef borderColor = RCTCreateCGColorRefFromSharedColor(borderMetrics.borderColors.left);
+    layer.borderColor = borderColor;
+    CGColorRelease(borderColor);
+    layer.cornerRadius = (CGFloat)borderMetrics.borderRadii.topLeft;
+
+    layer.cornerCurve = CornerCurveFromBorderCurve(borderMetrics.borderCurves.topLeft);
+
+    layer.backgroundColor = backgroundColor;
+  } else {
+    if (!_borderLayer) {
+      CALayer *borderLayer = [CALayer new];
+      borderLayer.zPosition = -1024.0f;
+      borderLayer.frame = layer.bounds;
+      borderLayer.magnificationFilter = kCAFilterNearest;
+      [layer addSublayer:borderLayer];
+      _borderLayer = borderLayer;
+    }
+
+    layer.backgroundColor = nil;
+    layer.borderWidth = 0;
+    layer.borderColor = nil;
+    layer.cornerRadius = 0;
+
+    RCTBorderColors borderColors = RCTCreateRCTBorderColorsFromBorderColors(borderMetrics.borderColors);
+
+    UIImage *image = RCTGetBorderImage(
+        RCTBorderStyleFromBorderStyle(borderMetrics.borderStyles.left),
+        layer.bounds.size,
+        RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii),
+        RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths),
+        borderColors,
+        backgroundColor,
+        self.clipsToBounds);
+
+    RCTReleaseRCTBorderColors(borderColors);
+
+    if (image == nil) {
+      _borderLayer.contents = nil;
+    } else {
+      CGSize imageSize = image.size;
+      UIEdgeInsets imageCapInsets = image.capInsets;
+      CGRect contentsCenter = CGRect{
+          CGPoint{imageCapInsets.left / imageSize.width, imageCapInsets.top / imageSize.height},
+          CGSize{(CGFloat)1.0 / imageSize.width, (CGFloat)1.0 / imageSize.height}};
+
+      _borderLayer.contents = (id)image.CGImage;
+      _borderLayer.contentsScale = image.scale;
+
+      BOOL isResizable = !UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero);
+      if (isResizable) {
+        _borderLayer.contentsCenter = contentsCenter;
+      } else {
+        _borderLayer.contentsCenter = CGRect{CGPoint{0.0, 0.0}, CGSize{1.0, 1.0}};
+      }
+    }
+
+    // If mutations are applied inside of Animation block, it may cause _borderLayer to be animated.
+    // To stop that, imperatively remove all animations from _borderLayer.
+    [_borderLayer removeAllAnimations];
+
+    // Stage 2.5. Custom Clipping Mask
+    CAShapeLayer *maskLayer = nil;
+    CGFloat cornerRadius = 0;
+    if (self.clipsToBounds) {
+      if (borderMetrics.borderRadii.isUniform()) {
+        // In this case we can simply use `cornerRadius` exclusively.
+        cornerRadius = borderMetrics.borderRadii.topLeft;
+      } else {
+        // In this case we have to generate masking layer manually.
+        CGPathRef path = RCTPathCreateWithRoundedRect(
+            self.bounds,
+            RCTGetCornerInsets(RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero),
+            nil);
+
+        maskLayer = [CAShapeLayer layer];
+        maskLayer.path = path;
+        CGPathRelease(path);
+      }
+    }
+
+    layer.cornerRadius = cornerRadius;
+    layer.mask = maskLayer;
+  }
+}
+
+#pragma mark - Accessibility
+
+- (NSObject *)accessibilityElement
+{
+  return self;
+}
+
+static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
+{
+  NSMutableString *result = [NSMutableString stringWithString:@""];
+  for (UIView *subview in view.subviews) {
+    NSString *label = subview.accessibilityLabel;
+    if (!label) {
+      label = RCTRecursiveAccessibilityLabel(subview);
+    }
+    if (label && label.length > 0) {
+      if (result.length > 0) {
+        [result appendString:@" "];
+      }
+      [result appendString:label];
+    }
+  }
+  return result;
+}
+
+- (NSString *)accessibilityLabel
+{
+  NSString *label = super.accessibilityLabel;
+  if (label) {
+    return label;
+  }
+
+  return RCTRecursiveAccessibilityLabel(self);
+}
+
+- (NSString *)accessibilityValue
+{
+  const auto &props = static_cast<const ViewProps &>(*_props);
+  const auto accessibilityState = props.accessibilityState.value_or(AccessibilityState{});
+
+  // Handle Switch.
+  if ((self.accessibilityTraits & AccessibilityTraitSwitch) == AccessibilityTraitSwitch) {
+    if (accessibilityState.checked == AccessibilityState::Checked) {
+      return @"1";
+    } else if (accessibilityState.checked == AccessibilityState::Unchecked) {
+      return @"0";
+    }
+  }
+
+  NSMutableArray *valueComponents = [NSMutableArray new];
+  NSString *roleString = (props.role != Role::None) ? [NSString stringWithUTF8String:toString(props.role).c_str()]
+                                                    : [NSString stringWithUTF8String:props.accessibilityRole.c_str()];
+
+  // In iOS, checkbox and radio buttons aren't recognized as traits. However,
+  // because our apps use checkbox and radio buttons often, we should announce
+  // these to screenreader users.  (They should already be familiar with them
+  // from using web).
+  if ([roleString isEqualToString:@"checkbox"]) {
+    [valueComponents addObject:RCTLocalizedString("checkbox", "checkable interactive control")];
+  }
+
+  if ([roleString isEqualToString:@"radio"]) {
+    [valueComponents
+        addObject:
+            RCTLocalizedString(
+                "radio button",
+                "a checkable input that when associated with other radio buttons, only one of which can be checked at a time")];
+  }
+
+  // Handle states which haven't already been handled.
+  if (accessibilityState.checked == AccessibilityState::Checked) {
+    [valueComponents
+        addObject:RCTLocalizedString("checked", "a checkbox, radio button, or other widget which is checked")];
+  }
+  if (accessibilityState.checked == AccessibilityState::Unchecked) {
+    [valueComponents
+        addObject:RCTLocalizedString("unchecked", "a checkbox, radio button, or other widget which is unchecked")];
+  }
+  if (accessibilityState.checked == AccessibilityState::Mixed) {
+    [valueComponents
+        addObject:RCTLocalizedString(
+                      "mixed", "a checkbox, radio button, or other widget which is both checked and unchecked")];
+  }
+  if (accessibilityState.expanded.value_or(false)) {
+    [valueComponents
+        addObject:RCTLocalizedString("expanded", "a menu, dialog, accordian panel, or other widget which is expanded")];
+  }
+
+  if (accessibilityState.busy) {
+    [valueComponents addObject:RCTLocalizedString("busy", "an element currently being updated or modified")];
+  }
+
+  // Using super.accessibilityValue:
+  // 1. to access the value that is set to accessibilityValue in updateProps
+  // 2. can't access from self.accessibilityElement because it resolves to self
+  if (super.accessibilityValue) {
+    [valueComponents addObject:super.accessibilityValue];
+  }
+
+  if (valueComponents.count > 0) {
+    return [valueComponents componentsJoinedByString:@", "];
+  }
+
+  return nil;
+}
+
+#pragma mark - Accessibility Events
+
+- (BOOL)shouldGroupAccessibilityChildren
+{
+  return YES;
+}
+
+- (NSArray<UIAccessibilityCustomAction *> *)accessibilityCustomActions
+{
+  const auto &accessibilityActions = _props->accessibilityActions;
+
+  if (accessibilityActions.empty()) {
+    return nil;
+  }
+
+  NSMutableArray<UIAccessibilityCustomAction *> *customActions = [NSMutableArray array];
+  for (const auto &accessibilityAction : accessibilityActions) {
+    [customActions
+        addObject:[[UIAccessibilityCustomAction alloc] initWithName:RCTNSStringFromString(accessibilityAction.name)
+                                                             target:self
+                                                           selector:@selector(didActivateAccessibilityCustomAction:)]];
+  }
+
+  return [customActions copy];
+}
+
+- (BOOL)accessibilityActivate
+{
+  if (_eventEmitter && _props->onAccessibilityTap) {
+    _eventEmitter->onAccessibilityTap();
+    return YES;
+  } else {
+    return NO;
+  }
+}
+
+- (BOOL)accessibilityPerformMagicTap
+{
+  if (_eventEmitter && _props->onAccessibilityMagicTap) {
+    _eventEmitter->onAccessibilityMagicTap();
+    return YES;
+  } else {
+    return NO;
+  }
+}
+
+- (BOOL)accessibilityPerformEscape
+{
+  if (_eventEmitter && _props->onAccessibilityEscape) {
+    _eventEmitter->onAccessibilityEscape();
+    return YES;
+  } else {
+    return NO;
+  }
+}
+
+- (BOOL)didActivateAccessibilityCustomAction:(UIAccessibilityCustomAction *)action
+{
+  if (_eventEmitter && _props->onAccessibilityAction) {
+    _eventEmitter->onAccessibilityAction(RCTStringFromNSString(action.name));
+    return YES;
+  } else {
+    return NO;
+  }
+}
+
+- (SharedTouchEventEmitter)touchEventEmitterAtPoint:(CGPoint)point
+{
+  return _eventEmitter;
+}
+
+- (NSString *)componentViewName_DO_NOT_USE_THIS_IS_BROKEN
+{
+  return RCTNSStringFromString([[self class] componentDescriptorProvider].name);
+}
+
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Can't the import generated Plugin.h because plugins are not in this BUCK target
+Class<RCTComponentViewProtocol> RCTViewCls(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+Class<RCTComponentViewProtocol> RCTViewCls(void)
+{
+  return RCTViewComponentView.class;
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewClassDescriptor.h

@@ -0,0 +1,37 @@
+/*
+ * 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/RCTComponentViewProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * Holds a native view class and a set of attributes associated with it.
+ */
+class RCTComponentViewClassDescriptor final {
+ public:
+  /*
+   * Associated (and owned) native view class.
+   */
+  Class<RCTComponentViewProtocol> viewClass;
+
+  /*
+   * Indicates a requirement to call on the view methods from
+   * `RCTMountingTransactionObserving` protocol.
+   */
+  bool observesMountingTransactionWillMount{false};
+  bool observesMountingTransactionDidMount{false};
+
+  /*
+   * Whether the component can be recycled or not
+   */
+  bool shouldBeRecycled{true};
+};
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewDescriptor.h

@@ -0,0 +1,53 @@
+/*
+ * 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/RCTComponentViewProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * Holds a native view instance and a set of attributes associated with it.
+ * Mounting infrastructure uses these objects to bookkeep views and cache their
+ * attributes for efficient access.
+ */
+class RCTComponentViewDescriptor final {
+ public:
+  /*
+   * Associated (and owned) native view instance.
+   */
+  __strong UIView<RCTComponentViewProtocol> *view = nil;
+
+  /*
+   * Indicates a requirement to call on the view methods from
+   * `RCTMountingTransactionObserving` protocol.
+   */
+  bool observesMountingTransactionWillMount{false};
+  bool observesMountingTransactionDidMount{false};
+  bool shouldBeRecycled{true};
+};
+
+inline bool operator==(const RCTComponentViewDescriptor &lhs, const RCTComponentViewDescriptor &rhs)
+{
+  return lhs.view == rhs.view;
+}
+
+inline bool operator!=(const RCTComponentViewDescriptor &lhs, const RCTComponentViewDescriptor &rhs)
+{
+  return lhs.view != rhs.view;
+}
+
+template <>
+struct std::hash<RCTComponentViewDescriptor> {
+  size_t operator()(const RCTComponentViewDescriptor &componentViewDescriptor) const
+  {
+    return std::hash<void *>()((__bridge void *)componentViewDescriptor.view);
+  }
+};
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewFactory.h

@@ -0,0 +1,71 @@
+/*
+ * 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/RCTComponentViewDescriptor.h>
+#import <React/RCTComponentViewProtocol.h>
+#import <jsi/jsi.h>
+#import <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+void RCTInstallNativeComponentRegistryBinding(facebook::jsi::Runtime &runtime);
+
+/**
+ * Protocol that can be implemented to provide some 3rd party components to Fabric.
+ * Fabric will check in this map whether there are some components that need to be registered.
+ */
+@protocol RCTComponentViewFactoryComponentProvider <NSObject>
+
+/**
+ * Return a dictionary of third party components where the `key` is the Component Handler and the `value` is a Class
+ * that conforms to `RCTComponentViewProtocol`.
+ */
+- (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents;
+
+@end
+
+/**
+ * Registry of supported component view classes that can instantiate
+ * view component instances by given component handle.
+ */
+@interface RCTComponentViewFactory : NSObject
+
+@property (nonatomic, weak) id<RCTComponentViewFactoryComponentProvider> thirdPartyFabricComponentsProvider;
+
+/**
+ * Constructs and returns an instance of the class with a bunch of already registered standard components.
+ */
++ (RCTComponentViewFactory *)currentComponentViewFactory;
+
+/**
+ * Registers a component view class in the factory.
+ */
+- (void)registerComponentViewClass:(Class<RCTComponentViewProtocol>)componentViewClass;
+
+/**
+ * Registers component if there is a matching class. Returns true if it matching class is found or the component has
+ * already been registered, false otherwise.
+ */
+- (BOOL)registerComponentIfPossible:(const std::string &)componentName;
+
+/**
+ * Creates a component view with given component handle.
+ */
+- (RCTComponentViewDescriptor)createComponentViewWithComponentHandle:(facebook::react::ComponentHandle)componentHandle;
+
+/**
+ * Creates *managed* `ComponentDescriptorRegistry`. After creation, the object continues to store a weak pointer to the
+ * registry and update it accordingly to the changes in the object.
+ */
+- (facebook::react::ComponentDescriptorRegistry::Shared)createComponentDescriptorRegistryWithParameters:
+    (facebook::react::ComponentDescriptorParameters)parameters;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewFactory.mm

@@ -0,0 +1,229 @@
+/*
+ * 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 "RCTComponentViewFactory.h"
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge.h>
+#import <React/RCTConversions.h>
+#import <React/RCTLog.h>
+
+#import <shared_mutex>
+#import <unordered_map>
+#import <unordered_set>
+
+#import <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#import <react/renderer/componentregistry/componentNameByReactViewName.h>
+#import <react/renderer/componentregistry/native/NativeComponentRegistryBinding.h>
+#import <react/renderer/core/PropsParserContext.h>
+#import <react/renderer/core/ReactPrimitives.h>
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+#import <RCTFabricComponentPlugin/RCTFabricPluginProvider.h>
+#else
+#import <React/RCTFabricComponentsPlugins.h>
+#endif
+
+#import <React/RCTComponentViewClassDescriptor.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <React/RCTImageComponentView.h>
+#import <React/RCTLegacyViewManagerInteropComponentView.h>
+#import <React/RCTMountingTransactionObserving.h>
+#import <React/RCTParagraphComponentView.h>
+#import <React/RCTRootComponentView.h>
+#import <React/RCTTextInputComponentView.h>
+#import <React/RCTUnimplementedViewComponentView.h>
+#import <React/RCTViewComponentView.h>
+
+#import <objc/runtime.h>
+
+using namespace facebook;
+using namespace facebook::react;
+
+// Allow JS runtime to register native components as needed. For static view configs.
+void RCTInstallNativeComponentRegistryBinding(facebook::jsi::Runtime &runtime)
+{
+  auto hasComponentProvider = [](const std::string &name) -> bool {
+    return [[RCTComponentViewFactory currentComponentViewFactory]
+        registerComponentIfPossible:componentNameByReactViewName(name)];
+  };
+  bindHasComponentProvider(runtime, std::move(hasComponentProvider));
+}
+
+static Class<RCTComponentViewProtocol> RCTComponentViewClassWithName(const char *componentName)
+{
+  return RCTFabricComponentsProvider(componentName);
+}
+
+@implementation RCTComponentViewFactory {
+  std::unordered_map<ComponentHandle, RCTComponentViewClassDescriptor> _componentViewClasses;
+  std::unordered_set<std::string> _registeredComponentsNames;
+  ComponentDescriptorProviderRegistry _providerRegistry;
+  std::shared_mutex _mutex;
+}
+
++ (RCTComponentViewFactory *)currentComponentViewFactory
+{
+  static dispatch_once_t onceToken;
+  static RCTComponentViewFactory *componentViewFactory;
+
+  dispatch_once(&onceToken, ^{
+    componentViewFactory = [RCTComponentViewFactory new];
+    [componentViewFactory registerComponentViewClass:[RCTRootComponentView class]];
+    [componentViewFactory registerComponentViewClass:[RCTParagraphComponentView class]];
+
+    componentViewFactory->_providerRegistry.setComponentDescriptorProviderRequest(
+        [](ComponentName requestedComponentName) {
+          [componentViewFactory registerComponentIfPossible:requestedComponentName];
+        });
+  });
+
+  return componentViewFactory;
+}
+
+- (RCTComponentViewClassDescriptor)_componentViewClassDescriptorFromClass:(Class<RCTComponentViewProtocol>)viewClass
+{
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundeclared-selector"
+  return RCTComponentViewClassDescriptor
+  {
+    .viewClass = viewClass,
+    .observesMountingTransactionWillMount =
+        (bool)class_respondsToSelector(viewClass, @selector(mountingTransactionWillMount:withSurfaceTelemetry:)),
+    .observesMountingTransactionDidMount =
+        (bool)class_respondsToSelector(viewClass, @selector(mountingTransactionDidMount:withSurfaceTelemetry:)),
+    .shouldBeRecycled = [viewClass respondsToSelector:@selector(shouldBeRecycled)]
+        ? (bool)[viewClass performSelector:@selector(shouldBeRecycled)]
+        : true,
+  };
+#pragma clang diagnostic pop
+}
+
+- (BOOL)registerComponentIfPossible:(const std::string &)name
+{
+  if (_registeredComponentsNames.find(name) != _registeredComponentsNames.end()) {
+    // Component has already been registered.
+    return YES;
+  }
+
+  // Paper name: we prepare this variables to warn the user
+  // when the component is registered in both Fabric and in the
+  // interop layer, so they can remove that
+  NSString *componentNameString = RCTNSStringFromString(name);
+
+  // Fallback 1: Call provider function for component view class.
+  Class<RCTComponentViewProtocol> klass = RCTComponentViewClassWithName(name.c_str());
+  if (klass) {
+    [self registerComponentViewClass:klass];
+    return YES;
+  }
+
+  // Fallback 2: Ask the provider and check in the dictionary provided
+  if (self.thirdPartyFabricComponentsProvider) {
+    // Test whether a provider has been passed to avoid potentially expensive conversions
+    // between C++ and ObjC strings.
+    NSString *objcName = [NSString stringWithCString:name.c_str() encoding:NSUTF8StringEncoding];
+    klass = self.thirdPartyFabricComponentsProvider.thirdPartyFabricComponents[objcName];
+    if (klass) {
+      [self registerComponentViewClass:klass];
+      return YES;
+    }
+  }
+
+  // Fallback 3: Try to use Paper Interop.
+  // TODO(T174674274): Implement lazy loading of legacy view managers in the new architecture.
+  if (RCTFabricInteropLayerEnabled() && [RCTLegacyViewManagerInteropComponentView isSupported:componentNameString]) {
+    RCTLogNewArchitectureValidation(
+        RCTNotAllowedInBridgeless,
+        self,
+        [NSString
+            stringWithFormat:
+                @"Legacy ViewManagers should be migrated to Fabric ComponentViews in the new architecture to reduce risk. Component using interop layer: %@",
+                componentNameString]);
+
+    auto flavor = std::make_shared<std::string const>(name);
+    auto componentName = ComponentName{flavor->c_str()};
+    auto componentHandle = reinterpret_cast<ComponentHandle>(componentName);
+    auto constructor = [RCTLegacyViewManagerInteropComponentView componentDescriptorProvider].constructor;
+
+    [self _addDescriptorToProviderRegistry:ComponentDescriptorProvider{
+                                               componentHandle, componentName, flavor, constructor}];
+
+    _componentViewClasses[componentHandle] =
+        [self _componentViewClassDescriptorFromClass:[RCTLegacyViewManagerInteropComponentView class]];
+    return YES;
+  }
+
+  // Fallback 4: use <UnimplementedView> if component doesn't exist.
+  auto flavor = std::make_shared<std::string const>(name);
+  auto componentName = ComponentName{flavor->c_str()};
+  auto componentHandle = reinterpret_cast<ComponentHandle>(componentName);
+  auto constructor = [RCTUnimplementedViewComponentView componentDescriptorProvider].constructor;
+
+  [self _addDescriptorToProviderRegistry:ComponentDescriptorProvider{
+                                             componentHandle, componentName, flavor, constructor}];
+
+  _componentViewClasses[componentHandle] =
+      [self _componentViewClassDescriptorFromClass:[RCTUnimplementedViewComponentView class]];
+
+  // No matching class exists for `name`.
+  return NO;
+}
+
+- (void)registerComponentViewClass:(Class<RCTComponentViewProtocol>)componentViewClass
+{
+  RCTAssert(componentViewClass, @"RCTComponentViewFactory: Provided `componentViewClass` is `nil`.");
+  std::unique_lock lock(_mutex);
+
+  auto componentDescriptorProvider = [componentViewClass componentDescriptorProvider];
+  _componentViewClasses[componentDescriptorProvider.handle] =
+      [self _componentViewClassDescriptorFromClass:componentViewClass];
+  [self _addDescriptorToProviderRegistry:componentDescriptorProvider];
+
+  auto supplementalComponentDescriptorProviders = [componentViewClass supplementalComponentDescriptorProviders];
+  for (const auto &provider : supplementalComponentDescriptorProviders) {
+    [self _addDescriptorToProviderRegistry:provider];
+  }
+}
+
+- (void)_addDescriptorToProviderRegistry:(const ComponentDescriptorProvider &)provider
+{
+  _registeredComponentsNames.insert(provider.name);
+  _providerRegistry.add(provider);
+}
+
+- (RCTComponentViewDescriptor)createComponentViewWithComponentHandle:(facebook::react::ComponentHandle)componentHandle
+{
+  RCTAssertMainQueue();
+  std::shared_lock lock(_mutex);
+
+  auto iterator = _componentViewClasses.find(componentHandle);
+  RCTAssert(
+      iterator != _componentViewClasses.end(),
+      @"ComponentView with componentHandle `%lli` (`%s`) not found.",
+      componentHandle,
+      (char *)componentHandle);
+  auto componentViewClassDescriptor = iterator->second;
+  Class viewClass = componentViewClassDescriptor.viewClass;
+
+  return RCTComponentViewDescriptor{
+      .view = [viewClass new],
+      .observesMountingTransactionWillMount = componentViewClassDescriptor.observesMountingTransactionWillMount,
+      .observesMountingTransactionDidMount = componentViewClassDescriptor.observesMountingTransactionDidMount,
+      .shouldBeRecycled = componentViewClassDescriptor.shouldBeRecycled,
+  };
+}
+
+- (facebook::react::ComponentDescriptorRegistry::Shared)createComponentDescriptorRegistryWithParameters:
+    (facebook::react::ComponentDescriptorParameters)parameters
+{
+  std::shared_lock lock(_mutex);
+
+  return _providerRegistry.createComponentDescriptorRegistry(parameters);
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewProtocol.h

@@ -0,0 +1,130 @@
+/*
+ * 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/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <react/renderer/core/EventEmitter.h>
+#import <react/renderer/core/LayoutMetrics.h>
+#import <react/renderer/core/Props.h>
+#import <react/renderer/core/State.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * Bitmask for all types of possible updates performing during mounting.
+ */
+typedef NS_OPTIONS(NSInteger, RNComponentViewUpdateMask) {
+  RNComponentViewUpdateMaskNone = 0,
+  RNComponentViewUpdateMaskProps = 1 << 0,
+  RNComponentViewUpdateMaskEventEmitter = 1 << 1,
+  RNComponentViewUpdateMaskState = 1 << 2,
+  RNComponentViewUpdateMaskLayoutMetrics = 1 << 3,
+
+  RNComponentViewUpdateMaskAll = RNComponentViewUpdateMaskProps | RNComponentViewUpdateMaskEventEmitter |
+      RNComponentViewUpdateMaskState | RNComponentViewUpdateMaskLayoutMetrics
+};
+
+/*
+ * Represents a `UIView` instance managed by React.
+ * All methods are non-@optional.
+ * `UIView+ComponentViewProtocol` category provides default implementation
+ * for all of them.
+ */
+@protocol RCTComponentViewProtocol <NSObject>
+
+/*
+ * Returns a `ComponentDescriptorProvider` of a particular `ComponentDescriptor` which this component view
+ * represents.
+ */
++ (facebook::react::ComponentDescriptorProvider)componentDescriptorProvider;
+
+/*
+ * Returns a list of supplemental  `ComponentDescriptorProvider`s (with do not have `ComponentView` counterparts) that
+ * require for this component view.
+ */
++ (std::vector<facebook::react::ComponentDescriptorProvider>)supplementalComponentDescriptorProviders;
+
+/*
+ * Called for mounting (attaching) a child component view inside `self`
+ * component view.
+ * Receiver must add `childComponentView` as a subview.
+ */
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index;
+
+/*
+ * Called for unmounting (detaching) a child component view from `self`
+ * component view.
+ * Receiver must remove `childComponentView` as a subview.
+ */
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index;
+
+/*
+ * Called for updating component's props.
+ * Receiver must update native view props accordingly changed props.
+ */
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps;
+
+/*
+ * Called for updating component's state.
+ * Receiver must update native view according to changed state.
+ */
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState;
+
+/*
+ * Called for updating component's event handlers set.
+ * Receiver must cache `eventEmitter` object inside and use it for emitting
+ * events when needed.
+ */
+- (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventEmitter;
+
+/*
+ * Called for updating component's layout metrics.
+ * Receiver must update `UIView` layout-related fields (such as `frame`,
+ * `bounds`, `layer.zPosition`, and so on) accordingly.
+ */
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics;
+
+/*
+ * Called when receiving a command
+ */
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args;
+
+/*
+ * Called right after all update methods were called for a particular component view.
+ * Useful for performing updates that require knowledge of several independent aspects of the compound mounting change
+ * (e.g. props *and* layout constraints).
+ */
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask;
+
+/*
+ * Called right after the component view is moved to a recycle pool.
+ * Receiver must reset any local state and release associated
+ * non-reusable resources.
+ */
+- (void)prepareForRecycle;
+
+/*
+ * Read the last props used to update the view.
+ */
+- (facebook::react::Props::Shared)props;
+
+- (BOOL)isJSResponder;
+- (void)setIsJSResponder:(BOOL)isJSResponder;
+
+/*
+ * This is broken. Do not use.
+ */
+- (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(nullable NSSet<NSString *> *)props;
+- (nullable NSSet<NSString *> *)propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewRegistry.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 <UIKit/UIKit.h>
+
+#import <React/RCTComponentViewDescriptor.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/RCTComponentViewProtocol.h>
+#import <react/renderer/core/ReactPrimitives.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Registry of native component views.
+ * Provides basic functionality for allocation, recycling, and querying (by tag) native view instances.
+ */
+@interface RCTComponentViewRegistry : NSObject
+
+@property (nonatomic, strong, readonly) RCTComponentViewFactory *componentViewFactory;
+
+/**
+ * Returns a descriptor referring to a native view instance from the recycle pool (or being created on demand)
+ * for given `componentHandle` and with given `tag`.
+ * #RefuseSingleUse
+ */
+- (const RCTComponentViewDescriptor &)dequeueComponentViewWithComponentHandle:
+                                          (facebook::react::ComponentHandle)componentHandle
+                                                                          tag:(facebook::react::Tag)tag;
+
+/**
+ * Puts a given native component view to the recycle pool.
+ * #RefuseSingleUse
+ */
+- (void)enqueueComponentViewWithComponentHandle:(facebook::react::ComponentHandle)componentHandle
+                                            tag:(facebook::react::Tag)tag
+                        componentViewDescriptor:(RCTComponentViewDescriptor)componentViewDescriptor;
+
+/**
+ * Returns a component view descriptor by given `tag`.
+ */
+- (const RCTComponentViewDescriptor &)componentViewDescriptorWithTag:(facebook::react::Tag)tag;
+
+/**
+ * Finds a native component view by given `tag`.
+ * Returns `nil` if there is no registered component with the `tag`.
+ */
+- (nullable UIView<RCTComponentViewProtocol> *)findComponentViewWithTag:(facebook::react::Tag)tag;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTComponentViewRegistry.mm

@@ -0,0 +1,126 @@
+/*
+ * 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 "RCTComponentViewRegistry.h"
+
+#import <Foundation/NSMapTable.h>
+#import <React/RCTAssert.h>
+#import <React/RCTConstants.h>
+
+#import <React/RCTImageComponentView.h>
+#import <React/RCTParagraphComponentView.h>
+#import <React/RCTViewComponentView.h>
+#import <unordered_map>
+
+using namespace facebook;
+using namespace facebook::react;
+
+const NSInteger RCTComponentViewRegistryRecyclePoolMaxSize = 1024;
+
+@implementation RCTComponentViewRegistry {
+  std::unordered_map<Tag, RCTComponentViewDescriptor> _registry;
+  std::unordered_map<ComponentHandle, std::vector<RCTComponentViewDescriptor>> _recyclePool;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _componentViewFactory = [RCTComponentViewFactory currentComponentViewFactory];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(handleApplicationDidReceiveMemoryWarningNotification)
+                                                 name:UIApplicationDidReceiveMemoryWarningNotification
+                                               object:nil];
+  }
+
+  return self;
+}
+
+- (const RCTComponentViewDescriptor &)dequeueComponentViewWithComponentHandle:(ComponentHandle)componentHandle
+                                                                          tag:(Tag)tag
+{
+  RCTAssertMainQueue();
+
+  RCTAssert(
+      _registry.find(tag) == _registry.end(),
+      @"RCTComponentViewRegistry: Attempt to dequeue already registered component.");
+
+  auto componentViewDescriptor = [self _dequeueComponentViewWithComponentHandle:componentHandle];
+  componentViewDescriptor.view.tag = tag;
+  auto it = _registry.insert({tag, componentViewDescriptor});
+  return it.first->second;
+}
+
+- (void)enqueueComponentViewWithComponentHandle:(ComponentHandle)componentHandle
+                                            tag:(Tag)tag
+                        componentViewDescriptor:(RCTComponentViewDescriptor)componentViewDescriptor
+{
+  RCTAssertMainQueue();
+
+  RCTAssert(
+      _registry.find(tag) != _registry.end(), @"RCTComponentViewRegistry: Attempt to enqueue unregistered component.");
+
+  _registry.erase(tag);
+  componentViewDescriptor.view.tag = 0;
+  [self _enqueueComponentViewWithComponentHandle:componentHandle componentViewDescriptor:componentViewDescriptor];
+}
+
+- (const RCTComponentViewDescriptor &)componentViewDescriptorWithTag:(Tag)tag
+{
+  RCTAssertMainQueue();
+  auto iterator = _registry.find(tag);
+  RCTAssert(iterator != _registry.end(), @"RCTComponentViewRegistry: Attempt to query unregistered component.");
+  return iterator->second;
+}
+
+- (nullable UIView<RCTComponentViewProtocol> *)findComponentViewWithTag:(Tag)tag
+{
+  RCTAssertMainQueue();
+  auto iterator = _registry.find(tag);
+  if (iterator == _registry.end()) {
+    return nil;
+  }
+  return iterator->second.view;
+}
+
+- (RCTComponentViewDescriptor)_dequeueComponentViewWithComponentHandle:(ComponentHandle)componentHandle
+{
+  RCTAssertMainQueue();
+  auto &recycledViews = _recyclePool[componentHandle];
+
+  if (recycledViews.empty()) {
+    return [self.componentViewFactory createComponentViewWithComponentHandle:componentHandle];
+  }
+
+  auto componentViewDescriptor = recycledViews.back();
+  recycledViews.pop_back();
+  return componentViewDescriptor;
+}
+
+- (void)_enqueueComponentViewWithComponentHandle:(ComponentHandle)componentHandle
+                         componentViewDescriptor:(RCTComponentViewDescriptor)componentViewDescriptor
+{
+  RCTAssertMainQueue();
+  auto &recycledViews = _recyclePool[componentHandle];
+
+  if (recycledViews.size() > RCTComponentViewRegistryRecyclePoolMaxSize || !componentViewDescriptor.shouldBeRecycled) {
+    return;
+  }
+
+  RCTAssert(
+      componentViewDescriptor.view.superview == nil, @"RCTComponentViewRegistry: Attempt to recycle a mounted view.");
+  [componentViewDescriptor.view prepareForRecycle];
+
+  recycledViews.push_back(componentViewDescriptor);
+}
+
+- (void)handleApplicationDidReceiveMemoryWarningNotification
+{
+  _recyclePool.clear();
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTMountingManager.h

@@ -0,0 +1,74 @@
+/*
+ * 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/RCTMountingManagerDelegate.h>
+#import <React/RCTPrimitives.h>
+#import <react/renderer/core/ComponentDescriptor.h>
+#import <react/renderer/core/RawProps.h>
+#import <react/renderer/core/ReactPrimitives.h>
+#import <react/renderer/mounting/MountingCoordinator.h>
+#import <react/renderer/mounting/ShadowView.h>
+#import <react/utils/ContextContainer.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTComponentViewRegistry;
+
+/**
+ * Manages mounting process.
+ */
+@interface RCTMountingManager : NSObject
+
+@property (nonatomic, weak) id<RCTMountingManagerDelegate> delegate;
+@property (nonatomic, strong) RCTComponentViewRegistry *componentViewRegistry;
+
+- (void)setContextContainer:(facebook::react::ContextContainer::Shared)contextContainer;
+
+/**
+ * Designates the view as a rendering viewport of a React Native surface.
+ * The provided view must not have any subviews, and the caller is not supposed to interact with the view hierarchy
+ * inside the provided view. The view hierarchy created by mounting infrastructure inside the provided view does not
+ * influence the intrinsic size of the view and cannot be measured using UIView/UIKit layout API.
+ * Must be called on the main thead.
+ */
+- (void)attachSurfaceToView:(UIView *)view surfaceId:(facebook::react::SurfaceId)surfaceId;
+
+/**
+ * Stops designating the view as a rendering viewport of a React Native surface.
+ */
+- (void)detachSurfaceFromView:(UIView *)view surfaceId:(facebook::react::SurfaceId)surfaceId;
+
+/**
+ * Schedule a mounting transaction to be performed on the main thread.
+ * Can be called from any thread.
+ */
+- (void)scheduleTransaction:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
+
+/**
+ * Dispatch a command to be performed on the main thread.
+ * Can be called from any thread.
+ */
+- (void)dispatchCommand:(ReactTag)reactTag commandName:(NSString *)commandName args:(NSArray *)args;
+
+/**
+ * Dispatch an accessibility event to be performed on the main thread.
+ * Can be called from any thread.
+ */
+- (void)sendAccessibilityEvent:(ReactTag)reactTag eventType:(NSString *)eventType;
+
+- (void)setIsJSResponder:(BOOL)isJSResponder
+    blockNativeResponder:(BOOL)blockNativeResponder
+           forShadowView:(const facebook::react::ShadowView &)shadowView;
+
+- (void)synchronouslyUpdateViewOnUIThread:(ReactTag)reactTag
+                             changedProps:(NSDictionary *)props
+                      componentDescriptor:(const facebook::react::ComponentDescriptor &)componentDescriptor;
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTMountingManager.mm

@@ -0,0 +1,345 @@
+/*
+ * 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 "RCTMountingManager.h"
+
+#import <QuartzCore/QuartzCore.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTComponent.h>
+#import <React/RCTFollyConvert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <react/config/ReactNativeConfig.h>
+#import <react/renderer/components/root/RootShadowNode.h>
+#import <react/renderer/core/LayoutableShadowNode.h>
+#import <react/renderer/core/RawProps.h>
+#import <react/renderer/debug/SystraceSection.h>
+#import <react/renderer/mounting/TelemetryController.h>
+#import <react/utils/CoreFeatures.h>
+
+#import <React/RCTComponentViewProtocol.h>
+#import <React/RCTComponentViewRegistry.h>
+#import <React/RCTConversions.h>
+#import <React/RCTMountingTransactionObserverCoordinator.h>
+
+using namespace facebook::react;
+
+static SurfaceId RCTSurfaceIdForView(UIView *view)
+{
+  do {
+    if (RCTIsReactRootView(@(view.tag))) {
+      return view.tag;
+    }
+    view = view.superview;
+  } while (view != nil);
+
+  return -1;
+}
+
+static void RCTPerformMountInstructions(
+    const ShadowViewMutationList &mutations,
+    RCTComponentViewRegistry *registry,
+    RCTMountingTransactionObserverCoordinator &observerCoordinator,
+    SurfaceId surfaceId)
+{
+  SystraceSection s("RCTPerformMountInstructions");
+
+  for (const auto &mutation : mutations) {
+    switch (mutation.type) {
+      case ShadowViewMutation::Create: {
+        auto &newChildShadowView = mutation.newChildShadowView;
+        auto &newChildViewDescriptor =
+            [registry dequeueComponentViewWithComponentHandle:newChildShadowView.componentHandle
+                                                          tag:newChildShadowView.tag];
+        observerCoordinator.registerViewComponentDescriptor(newChildViewDescriptor, surfaceId);
+        break;
+      }
+
+      case ShadowViewMutation::Delete: {
+        auto &oldChildShadowView = mutation.oldChildShadowView;
+        auto &oldChildViewDescriptor = [registry componentViewDescriptorWithTag:oldChildShadowView.tag];
+
+        observerCoordinator.unregisterViewComponentDescriptor(oldChildViewDescriptor, surfaceId);
+
+        [registry enqueueComponentViewWithComponentHandle:oldChildShadowView.componentHandle
+                                                      tag:oldChildShadowView.tag
+                                  componentViewDescriptor:oldChildViewDescriptor];
+        break;
+      }
+
+      case ShadowViewMutation::Insert: {
+        auto &newChildShadowView = mutation.newChildShadowView;
+        auto &parentShadowView = mutation.parentShadowView;
+        auto &newChildViewDescriptor = [registry componentViewDescriptorWithTag:newChildShadowView.tag];
+        auto &parentViewDescriptor = [registry componentViewDescriptorWithTag:parentShadowView.tag];
+
+        UIView<RCTComponentViewProtocol> *newChildComponentView = newChildViewDescriptor.view;
+
+        RCTAssert(newChildShadowView.props, @"`newChildShadowView.props` must not be null.");
+
+        [newChildComponentView updateProps:newChildShadowView.props oldProps:nullptr];
+        [newChildComponentView updateEventEmitter:newChildShadowView.eventEmitter];
+        [newChildComponentView updateState:newChildShadowView.state oldState:nullptr];
+        [newChildComponentView updateLayoutMetrics:newChildShadowView.layoutMetrics
+                                  oldLayoutMetrics:EmptyLayoutMetrics];
+        [newChildComponentView finalizeUpdates:RNComponentViewUpdateMaskAll];
+
+        [parentViewDescriptor.view mountChildComponentView:newChildComponentView index:mutation.index];
+        break;
+      }
+
+      case ShadowViewMutation::Remove: {
+        auto &oldChildShadowView = mutation.oldChildShadowView;
+        auto &parentShadowView = mutation.parentShadowView;
+        auto &oldChildViewDescriptor = [registry componentViewDescriptorWithTag:oldChildShadowView.tag];
+        auto &parentViewDescriptor = [registry componentViewDescriptorWithTag:parentShadowView.tag];
+        [parentViewDescriptor.view unmountChildComponentView:oldChildViewDescriptor.view index:mutation.index];
+        break;
+      }
+
+      case ShadowViewMutation::RemoveDeleteTree: {
+        // TODO - not supported yet
+        break;
+      }
+
+      case ShadowViewMutation::Update: {
+        auto &oldChildShadowView = mutation.oldChildShadowView;
+        auto &newChildShadowView = mutation.newChildShadowView;
+        auto &newChildViewDescriptor = [registry componentViewDescriptorWithTag:newChildShadowView.tag];
+        UIView<RCTComponentViewProtocol> *newChildComponentView = newChildViewDescriptor.view;
+
+        auto mask = RNComponentViewUpdateMask{};
+
+        RCTAssert(newChildShadowView.props, @"`newChildShadowView.props` must not be null.");
+
+        if (oldChildShadowView.props != newChildShadowView.props) {
+          [newChildComponentView updateProps:newChildShadowView.props oldProps:oldChildShadowView.props];
+          mask |= RNComponentViewUpdateMaskProps;
+        }
+
+        if (oldChildShadowView.eventEmitter != newChildShadowView.eventEmitter) {
+          [newChildComponentView updateEventEmitter:newChildShadowView.eventEmitter];
+          mask |= RNComponentViewUpdateMaskEventEmitter;
+        }
+
+        if (oldChildShadowView.state != newChildShadowView.state) {
+          [newChildComponentView updateState:newChildShadowView.state oldState:oldChildShadowView.state];
+          mask |= RNComponentViewUpdateMaskState;
+        }
+
+        if (oldChildShadowView.layoutMetrics != newChildShadowView.layoutMetrics) {
+          [newChildComponentView updateLayoutMetrics:newChildShadowView.layoutMetrics
+                                    oldLayoutMetrics:oldChildShadowView.layoutMetrics];
+          mask |= RNComponentViewUpdateMaskLayoutMetrics;
+        }
+
+        if (mask != RNComponentViewUpdateMaskNone) {
+          [newChildComponentView finalizeUpdates:mask];
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+@implementation RCTMountingManager {
+  RCTMountingTransactionObserverCoordinator _observerCoordinator;
+  BOOL _transactionInFlight;
+  BOOL _followUpTransactionRequired;
+  ContextContainer::Shared _contextContainer;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _componentViewRegistry = [RCTComponentViewRegistry new];
+  }
+
+  return self;
+}
+
+- (void)setContextContainer:(ContextContainer::Shared)contextContainer
+{
+  _contextContainer = contextContainer;
+}
+
+- (void)attachSurfaceToView:(UIView *)view surfaceId:(SurfaceId)surfaceId
+{
+  RCTAssertMainQueue();
+
+  RCTAssert(view.subviews.count == 0, @"The view must not have any subviews.");
+
+  RCTComponentViewDescriptor rootViewDescriptor =
+      [_componentViewRegistry dequeueComponentViewWithComponentHandle:RootShadowNode::Handle() tag:surfaceId];
+  [view addSubview:rootViewDescriptor.view];
+}
+
+- (void)detachSurfaceFromView:(UIView *)view surfaceId:(SurfaceId)surfaceId
+{
+  RCTAssertMainQueue();
+  RCTComponentViewDescriptor rootViewDescriptor = [_componentViewRegistry componentViewDescriptorWithTag:surfaceId];
+
+  [rootViewDescriptor.view removeFromSuperview];
+
+  [_componentViewRegistry enqueueComponentViewWithComponentHandle:RootShadowNode::Handle()
+                                                              tag:surfaceId
+                                          componentViewDescriptor:rootViewDescriptor];
+}
+
+- (void)scheduleTransaction:(MountingCoordinator::Shared)mountingCoordinator
+{
+  if (RCTIsMainQueue()) {
+    // Already on the proper thread, so:
+    // * No need to do a thread jump;
+    // * No need to do expensive copy of all mutations;
+    // * No need to allocate a block.
+    [self initiateTransaction:*mountingCoordinator];
+    return;
+  }
+
+  RCTExecuteOnMainQueue(^{
+    RCTAssertMainQueue();
+    [self initiateTransaction:*mountingCoordinator];
+  });
+}
+
+- (void)dispatchCommand:(ReactTag)reactTag commandName:(NSString *)commandName args:(NSArray *)args
+{
+  if (RCTIsMainQueue()) {
+    // Already on the proper thread, so:
+    // * No need to do a thread jump;
+    // * No need to allocate a block.
+    [self synchronouslyDispatchCommandOnUIThread:reactTag commandName:commandName args:args];
+    return;
+  }
+
+  RCTExecuteOnMainQueue(^{
+    [self synchronouslyDispatchCommandOnUIThread:reactTag commandName:commandName args:args];
+  });
+}
+
+- (void)sendAccessibilityEvent:(ReactTag)reactTag eventType:(NSString *)eventType
+{
+  if (RCTIsMainQueue()) {
+    // Already on the proper thread, so:
+    // * No need to do a thread jump;
+    // * No need to allocate a block.
+    [self synchronouslyDispatchAccessbilityEventOnUIThread:reactTag eventType:eventType];
+    return;
+  }
+
+  RCTExecuteOnMainQueue(^{
+    [self synchronouslyDispatchAccessbilityEventOnUIThread:reactTag eventType:eventType];
+  });
+}
+
+- (void)initiateTransaction:(const MountingCoordinator &)mountingCoordinator
+{
+  SystraceSection s("-[RCTMountingManager initiateTransaction:]");
+  RCTAssertMainQueue();
+
+  if (_transactionInFlight) {
+    _followUpTransactionRequired = YES;
+    return;
+  }
+
+  do {
+    _followUpTransactionRequired = NO;
+    _transactionInFlight = YES;
+    [self performTransaction:mountingCoordinator];
+    _transactionInFlight = NO;
+  } while (_followUpTransactionRequired);
+}
+
+- (void)performTransaction:(const MountingCoordinator &)mountingCoordinator
+{
+  SystraceSection s("-[RCTMountingManager performTransaction:]");
+  RCTAssertMainQueue();
+
+  auto surfaceId = mountingCoordinator.getSurfaceId();
+
+  mountingCoordinator.getTelemetryController().pullTransaction(
+      [&](const MountingTransaction &transaction, const SurfaceTelemetry &surfaceTelemetry) {
+        [self.delegate mountingManager:self willMountComponentsWithRootTag:surfaceId];
+        _observerCoordinator.notifyObserversMountingTransactionWillMount(transaction, surfaceTelemetry);
+      },
+      [&](const MountingTransaction &transaction, const SurfaceTelemetry &surfaceTelemetry) {
+        RCTPerformMountInstructions(
+            transaction.getMutations(), _componentViewRegistry, _observerCoordinator, surfaceId);
+      },
+      [&](const MountingTransaction &transaction, const SurfaceTelemetry &surfaceTelemetry) {
+        _observerCoordinator.notifyObserversMountingTransactionDidMount(transaction, surfaceTelemetry);
+        [self.delegate mountingManager:self didMountComponentsWithRootTag:surfaceId];
+      });
+}
+
+- (void)setIsJSResponder:(BOOL)isJSResponder
+    blockNativeResponder:(BOOL)blockNativeResponder
+           forShadowView:(const facebook::react::ShadowView &)shadowView
+{
+  ReactTag reactTag = shadowView.tag;
+  RCTExecuteOnMainQueue(^{
+    UIView<RCTComponentViewProtocol> *componentView = [self->_componentViewRegistry findComponentViewWithTag:reactTag];
+    [componentView setIsJSResponder:isJSResponder];
+  });
+}
+
+- (void)synchronouslyUpdateViewOnUIThread:(ReactTag)reactTag
+                             changedProps:(NSDictionary *)props
+                      componentDescriptor:(const ComponentDescriptor &)componentDescriptor
+{
+  RCTAssertMainQueue();
+  UIView<RCTComponentViewProtocol> *componentView = [_componentViewRegistry findComponentViewWithTag:reactTag];
+  SurfaceId surfaceId = RCTSurfaceIdForView(componentView);
+  Props::Shared oldProps = [componentView props];
+  Props::Shared newProps = componentDescriptor.cloneProps(
+      PropsParserContext{surfaceId, *_contextContainer.get()}, oldProps, RawProps(convertIdToFollyDynamic(props)));
+
+  NSSet<NSString *> *propKeys = componentView.propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN ?: [NSSet new];
+  propKeys = [propKeys setByAddingObjectsFromArray:props.allKeys];
+  componentView.propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = nil;
+  [componentView updateProps:newProps oldProps:oldProps];
+  componentView.propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = propKeys;
+
+  const auto &newViewProps = static_cast<const ViewProps &>(*newProps);
+
+  if (props[@"transform"]) {
+    auto layoutMetrics = LayoutMetrics();
+    layoutMetrics.frame.size.width = componentView.layer.bounds.size.width;
+    layoutMetrics.frame.size.height = componentView.layer.bounds.size.height;
+    CATransform3D newTransform = RCTCATransform3DFromTransformMatrix(newViewProps.resolveTransform(layoutMetrics));
+    if (!CATransform3DEqualToTransform(newTransform, componentView.layer.transform)) {
+      componentView.layer.transform = newTransform;
+    }
+  }
+  if (props[@"opacity"] && componentView.layer.opacity != (float)newViewProps.opacity) {
+    componentView.layer.opacity = newViewProps.opacity;
+  }
+
+  [componentView finalizeUpdates:RNComponentViewUpdateMaskProps];
+}
+
+- (void)synchronouslyDispatchCommandOnUIThread:(ReactTag)reactTag
+                                   commandName:(NSString *)commandName
+                                          args:(NSArray *)args
+{
+  RCTAssertMainQueue();
+  UIView<RCTComponentViewProtocol> *componentView = [_componentViewRegistry findComponentViewWithTag:reactTag];
+  [componentView handleCommand:commandName args:args];
+}
+
+- (void)synchronouslyDispatchAccessbilityEventOnUIThread:(ReactTag)reactTag eventType:(NSString *)eventType
+{
+  if ([@"focus" isEqualToString:eventType]) {
+    UIView<RCTComponentViewProtocol> *componentView = [_componentViewRegistry findComponentViewWithTag:reactTag];
+    UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, componentView);
+  }
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTMountingManagerDelegate.h

@@ -0,0 +1,37 @@
+/*
+ * 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/RCTPrimitives.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTMountingManager;
+
+/**
+ * MountingManager's delegate.
+ */
+@protocol RCTMountingManagerDelegate <NSObject>
+
+/*
+ * Called right *before* execution of mount items which affect a Surface with
+ * given `rootTag`.
+ * Always called on the main queue.
+ */
+- (void)mountingManager:(RCTMountingManager *)mountingManager willMountComponentsWithRootTag:(ReactTag)MountingManager;
+
+/*
+ * Called right *after* execution of mount items which affect a Surface with
+ * given `rootTag`.
+ * Always called on the main queue.
+ */
+- (void)mountingManager:(RCTMountingManager *)mountingManager didMountComponentsWithRootTag:(ReactTag)rootTag;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTMountingTransactionObserverCoordinator.h

@@ -0,0 +1,45 @@
+/*
+ * 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 <React/RCTComponentViewDescriptor.h>
+#import <unordered_map>
+#import <unordered_set>
+
+#import "RCTMountingTransactionObserverCoordinator.h"
+
+#include <react/renderer/mounting/MountingTransaction.h>
+
+class RCTMountingTransactionObserverCoordinator final {
+ public:
+  /*
+   * Registers (and unregisters) specified `componentViewDescriptor` in the
+   * registry of views that need to be notified. Does nothing if a particular
+   * `componentViewDescriptor` does not listen the events.
+   */
+  void registerViewComponentDescriptor(
+      const RCTComponentViewDescriptor& componentViewDescriptor,
+      facebook::react::SurfaceId surfaceId);
+  void unregisterViewComponentDescriptor(
+      const RCTComponentViewDescriptor& componentViewDescriptor,
+      facebook::react::SurfaceId surfaceId);
+
+  /*
+   * To be called from `RCTMountingManager`.
+   */
+  void notifyObserversMountingTransactionWillMount(
+      const facebook::react::MountingTransaction& transaction,
+      const facebook::react::SurfaceTelemetry& surfaceTelemetry) const;
+  void notifyObserversMountingTransactionDidMount(
+      const facebook::react::MountingTransaction& transaction,
+      const facebook::react::SurfaceTelemetry& surfaceTelemetry) const;
+
+ private:
+  std::unordered_map<
+      facebook::react::SurfaceId,
+      std::unordered_set<RCTComponentViewDescriptor>>
+      registry_;
+};

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTMountingTransactionObserverCoordinator.mm

@@ -0,0 +1,76 @@
+/*
+ * 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 "RCTMountingTransactionObserverCoordinator.h"
+
+#import "RCTMountingTransactionObserving.h"
+
+using namespace facebook::react;
+
+void RCTMountingTransactionObserverCoordinator::registerViewComponentDescriptor(
+    const RCTComponentViewDescriptor &componentViewDescriptor,
+    SurfaceId surfaceId)
+{
+  if (!componentViewDescriptor.observesMountingTransactionWillMount &&
+      !componentViewDescriptor.observesMountingTransactionDidMount) {
+    return;
+  }
+
+  auto &surfaceRegistry = registry_[surfaceId];
+  assert(surfaceRegistry.count(componentViewDescriptor) == 0);
+  surfaceRegistry.insert(componentViewDescriptor);
+}
+
+void RCTMountingTransactionObserverCoordinator::unregisterViewComponentDescriptor(
+    const RCTComponentViewDescriptor &componentViewDescriptor,
+    SurfaceId surfaceId)
+{
+  if (!componentViewDescriptor.observesMountingTransactionWillMount &&
+      !componentViewDescriptor.observesMountingTransactionDidMount) {
+    return;
+  }
+
+  auto &surfaceRegistry = registry_[surfaceId];
+  assert(surfaceRegistry.count(componentViewDescriptor) == 1);
+  surfaceRegistry.erase(componentViewDescriptor);
+}
+
+void RCTMountingTransactionObserverCoordinator::notifyObserversMountingTransactionWillMount(
+    const MountingTransaction &transaction,
+    const SurfaceTelemetry &surfaceTelemetry) const
+{
+  auto surfaceId = transaction.getSurfaceId();
+  auto surfaceRegistryIterator = registry_.find(surfaceId);
+  if (surfaceRegistryIterator == registry_.end()) {
+    return;
+  }
+  auto &surfaceRegistry = surfaceRegistryIterator->second;
+  for (const auto &componentViewDescriptor : surfaceRegistry) {
+    if (componentViewDescriptor.observesMountingTransactionWillMount) {
+      [(id<RCTMountingTransactionObserving>)componentViewDescriptor.view mountingTransactionWillMount:transaction
+                                                                                 withSurfaceTelemetry:surfaceTelemetry];
+    }
+  }
+}
+
+void RCTMountingTransactionObserverCoordinator::notifyObserversMountingTransactionDidMount(
+    const MountingTransaction &transaction,
+    const SurfaceTelemetry &surfaceTelemetry) const
+{
+  auto surfaceId = transaction.getSurfaceId();
+  auto surfaceRegistryIterator = registry_.find(surfaceId);
+  if (surfaceRegistryIterator == registry_.end()) {
+    return;
+  }
+  auto &surfaceRegistry = surfaceRegistryIterator->second;
+  for (const auto &componentViewDescriptor : surfaceRegistry) {
+    if (componentViewDescriptor.observesMountingTransactionDidMount) {
+      [(id<RCTMountingTransactionObserving>)componentViewDescriptor.view mountingTransactionDidMount:transaction
+                                                                                withSurfaceTelemetry:surfaceTelemetry];
+    }
+  }
+}

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/RCTMountingTransactionObserving.h

@@ -0,0 +1,66 @@
+/*
+ * 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>
+
+#include <react/renderer/mounting/MountingTransaction.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * # Achtung!
+ * Remember, with great power comes great responsibility.
+ * Observers of this protocol are being called several times on every single mount transaction. Any thoughtless or
+ * suboptimal implementation of this protocol will slow down the whole app. Please, be responsible.
+ *
+ * # Usecases
+ * React Native platform-specific mounting layer has limitations when it comes to notifying view components about
+ * (coming or just happened) changes in the view tree. Implementing that generically for all components would make
+ * everything way to slow. For instance, the mounting layer does not have dedicated APIs to notify some component that:
+ * - Some ancestor of the component was reparented;
+ * - Some descendant of the component was added, removed or reparented;
+ * - Some ancestor of the component got new layout metrics (which might affect the absolute position of the component);
+ * - The transaction which affected the component's children just finished.
+ *
+ * If some very specific component (e.g. a performance logger) needs to handle some of the similar use-cases, it might
+ * rely on this protocol.
+ *
+ * # How to use
+ * - Declare conformance to this protocol for the ComponentView class.
+ * - Implement methods *only* suitable for a particular use case. Do not implement all methods if it is not strictly
+ * required.
+ * - Alternatively, an observer can be registered explicitly via `RCTSurface`.
+ *
+ * # Implementation details
+ * The framework checks all registered view classes for conformance to the protocol and for a set of implemented
+ * methods, then it stores this information for future use. When a view got created, the framework checks the info
+ * associated with the class and adds the view object to the list of listeners of the particular events (if needed).
+ * When a view got destroyed, the framework removes the view from suitable collections.
+ */
+@protocol RCTMountingTransactionObserving <NSObject>
+
+@optional
+
+/*
+ * Called right before the fist mutation instruction is executed.
+ * Is not being called for a component view which is being mounted as part of the transaction (because the view is not
+ * registered as an observer yet).
+ */
+- (void)mountingTransactionWillMount:(const facebook::react::MountingTransaction &)transaction
+                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry;
+
+/*
+ * Called right after the last mutation instruction is executed.
+ * Is not being called for a component view which was being unmounted as part of the transaction (because the view is
+ * not registered as an observer already).
+ */
+- (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
+               withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/UIView+ComponentViewProtocol.h

@@ -0,0 +1,51 @@
+/*
+ * 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/RCTComponentViewProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Default implementation of RCTComponentViewProtocol.
+ */
+@interface UIView (ComponentViewProtocol) <RCTComponentViewProtocol>
+
++ (std::vector<facebook::react::ComponentDescriptorProvider>)supplementalComponentDescriptorProviders;
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index;
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index;
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps;
+
+- (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventEmitter;
+
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState;
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics;
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask;
+
+- (void)prepareForRecycle;
+
+- (facebook::react::Props::Shared)props;
+
+- (void)setIsJSResponder:(BOOL)isJSResponder;
+
+- (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(nullable NSSet<NSString *> *)props;
+- (nullable NSSet<NSString *> *)propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
+
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Mounting/UIView+ComponentViewProtocol.mm

@@ -0,0 +1,171 @@
+/*
+ * 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 "UIView+ComponentViewProtocol.h"
+
+#import <React/RCTAssert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "RCTConversions.h"
+
+using namespace facebook::react;
+
+@implementation UIView (ComponentViewProtocol)
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  RCTAssert(NO, @"`-[RCTComponentViewProtocol componentDescriptorProvider]` must be implemented in a concrete class.");
+  return {};
+}
+
++ (std::vector<facebook::react::ComponentDescriptorProvider>)supplementalComponentDescriptorProviders
+{
+  return {};
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      childComponentView.superview == nil,
+      @"Attempt to mount already mounted component view. (parent: %@, child: %@, index: %@, existing parent: %@)",
+      self,
+      childComponentView,
+      @(index),
+      @([childComponentView.superview tag]));
+  [self insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      childComponentView.superview == self,
+      @"Attempt to unmount a view which is mounted inside different view. (parent: %@, child: %@, index: %@)",
+      self,
+      childComponentView,
+      @(index));
+  RCTAssert(
+      (self.subviews.count > index) && [self.subviews objectAtIndex:index] == childComponentView,
+      @"Attempt to unmount a view which has a different index. (parent: %@, child: %@, index: %@, actual index: %@, tag at index: %@)",
+      self,
+      childComponentView,
+      @(index),
+      @([self.subviews indexOfObject:childComponentView]),
+      @([[self.subviews objectAtIndex:index] tag]));
+
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  // Default implementation does nothing.
+}
+
+- (void)updateEventEmitter:(const EventEmitter::Shared &)eventEmitter
+{
+  // Default implementation does nothing.
+}
+
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState
+{
+  // Default implementation does nothing.
+}
+
+- (void)handleCommand:(NSString *)commandName args:(NSArray *)args
+{
+  // Default implementation does nothing.
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  bool forceUpdate = oldLayoutMetrics == EmptyLayoutMetrics;
+
+  if (forceUpdate || (layoutMetrics.frame != oldLayoutMetrics.frame)) {
+    CGRect frame = RCTCGRectFromRect(layoutMetrics.frame);
+
+    if (!std::isfinite(frame.origin.x) || !std::isfinite(frame.origin.y) || !std::isfinite(frame.size.width) ||
+        !std::isfinite(frame.size.height)) {
+      // CALayer will crash if we pass NaN or Inf values.
+      // It's unclear how to detect this case on cross-platform manner holistically, so we have to do it on the mounting
+      // layer as well. NaN/Inf is a kinda valid result of some math operations. Even if we can (and should) detect (and
+      // report early) incorrect (NaN and Inf) values which come from JavaScript side, we sometimes cannot backtrace the
+      // sources of a calculation that produced an incorrect/useless result.
+      RCTLogWarn(
+          @"-[UIView(ComponentViewProtocol) updateLayoutMetrics:oldLayoutMetrics:]: Received invalid layout metrics (%@) for a view (%@).",
+          NSStringFromCGRect(frame),
+          self);
+    } else {
+      // Note: Changing `frame` when `layer.transform` is not the `identity transform` is undefined behavior.
+      // Therefore, we must use `center` and `bounds`.
+      self.center = CGPoint{CGRectGetMidX(frame), CGRectGetMidY(frame)};
+      self.bounds = CGRect{CGPointZero, frame.size};
+    }
+  }
+
+  if (forceUpdate || (layoutMetrics.layoutDirection != oldLayoutMetrics.layoutDirection)) {
+    self.semanticContentAttribute = layoutMetrics.layoutDirection == LayoutDirection::RightToLeft
+        ? UISemanticContentAttributeForceRightToLeft
+        : UISemanticContentAttributeForceLeftToRight;
+  }
+
+  if (forceUpdate || (layoutMetrics.displayType != oldLayoutMetrics.displayType)) {
+    self.hidden = layoutMetrics.displayType == DisplayType::None;
+  }
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
+{
+  // Default implementation does nothing.
+}
+
+- (void)prepareForRecycle
+{
+  // Default implementation does nothing.
+}
+
+- (facebook::react::Props::Shared)props
+{
+  RCTAssert(NO, @"props access should be implemented by RCTViewComponentView.");
+  return nullptr;
+}
+
+- (BOOL)isJSResponder
+{
+  // Default implementation always returns `NO`.
+  return NO;
+}
+
+- (void)setIsJSResponder:(BOOL)isJSResponder
+{
+  // Default implementation does nothing.
+}
+
+- (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(nullable NSSet<NSString *> *)propKeys
+{
+  // Default implementation does nothing.
+}
+
+- (nullable NSSet<NSString *> *)propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN
+{
+  return nil;
+}
+
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
+{
+  clipRect = [clipView convertRect:clipRect toView:self];
+
+  // Normal views don't support unmounting, so all
+  // this does is forward message to our subviews,
+  // in case any of those do support it
+  for (UIView *subview in self.subviews) {
+    [subview updateClippedSubviewsWithClipRect:clipRect relativeToView:self];
+  }
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTConversions.h

@@ -0,0 +1,187 @@
+/*
+ * 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/renderer/components/view/AccessibilityPrimitives.h>
+#import <react/renderer/components/view/primitives.h>
+#import <react/renderer/core/LayoutPrimitives.h>
+#import <react/renderer/graphics/Color.h>
+#import <react/renderer/graphics/RCTPlatformColorUtils.h>
+#import <react/renderer/graphics/Transform.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+inline NSString *RCTNSStringFromString(
+    const std::string &string,
+    const NSStringEncoding &encoding = NSUTF8StringEncoding)
+{
+  return [NSString stringWithCString:string.c_str() encoding:encoding] ?: @"";
+}
+
+inline NSString *_Nullable RCTNSStringFromStringNilIfEmpty(
+    const std::string &string,
+    const NSStringEncoding &encoding = NSUTF8StringEncoding)
+{
+  return string.empty() ? nil : RCTNSStringFromString(string, encoding);
+}
+
+inline std::string RCTStringFromNSString(NSString *string)
+{
+  return std::string{string.UTF8String ?: ""};
+}
+
+inline UIColor *_Nullable RCTUIColorFromSharedColor(const facebook::react::SharedColor &sharedColor)
+{
+  return RCTPlatformColorFromColor(*sharedColor);
+}
+
+inline CF_RETURNS_RETAINED CGColorRef _Nullable RCTCreateCGColorRefFromSharedColor(
+    const facebook::react::SharedColor &sharedColor)
+{
+  return CGColorRetain(RCTUIColorFromSharedColor(sharedColor).CGColor);
+}
+
+inline CGPoint RCTCGPointFromPoint(const facebook::react::Point &point)
+{
+  return {point.x, point.y};
+}
+
+inline CGSize RCTCGSizeFromSize(const facebook::react::Size &size)
+{
+  return {size.width, size.height};
+}
+
+inline CGRect RCTCGRectFromRect(const facebook::react::Rect &rect)
+{
+  return {RCTCGPointFromPoint(rect.origin), RCTCGSizeFromSize(rect.size)};
+}
+
+inline UIEdgeInsets RCTUIEdgeInsetsFromEdgeInsets(const facebook::react::EdgeInsets &edgeInsets)
+{
+  return {edgeInsets.top, edgeInsets.left, edgeInsets.bottom, edgeInsets.right};
+}
+
+const UIAccessibilityTraits AccessibilityTraitSwitch = 0x20000000000001;
+
+inline UIAccessibilityTraits RCTUIAccessibilityTraitsFromAccessibilityTraits(
+    facebook::react::AccessibilityTraits accessibilityTraits)
+{
+  using AccessibilityTraits = facebook::react::AccessibilityTraits;
+  UIAccessibilityTraits result = UIAccessibilityTraitNone;
+  if ((accessibilityTraits & AccessibilityTraits::Button) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitButton;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::Link) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitLink;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::Image) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitImage;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::Selected) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitSelected;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::PlaysSound) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitPlaysSound;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::KeyboardKey) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitKeyboardKey;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::StaticText) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitStaticText;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::SummaryElement) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitSummaryElement;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::NotEnabled) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitNotEnabled;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::UpdatesFrequently) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitUpdatesFrequently;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::SearchField) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitSearchField;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::StartsMediaSession) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitStartsMediaSession;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::Adjustable) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitAdjustable;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::AllowsDirectInteraction) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitAllowsDirectInteraction;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::CausesPageTurn) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitCausesPageTurn;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::Header) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitHeader;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::Switch) != AccessibilityTraits::None) {
+    result |= AccessibilityTraitSwitch;
+  }
+  if ((accessibilityTraits & AccessibilityTraits::TabBar) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitTabBar;
+  }
+  return result;
+};
+
+inline CATransform3D RCTCATransform3DFromTransformMatrix(const facebook::react::Transform &transformMatrix)
+{
+  return {
+      (CGFloat)transformMatrix.matrix[0],
+      (CGFloat)transformMatrix.matrix[1],
+      (CGFloat)transformMatrix.matrix[2],
+      (CGFloat)transformMatrix.matrix[3],
+      (CGFloat)transformMatrix.matrix[4],
+      (CGFloat)transformMatrix.matrix[5],
+      (CGFloat)transformMatrix.matrix[6],
+      (CGFloat)transformMatrix.matrix[7],
+      (CGFloat)transformMatrix.matrix[8],
+      (CGFloat)transformMatrix.matrix[9],
+      (CGFloat)transformMatrix.matrix[10],
+      (CGFloat)transformMatrix.matrix[11],
+      (CGFloat)transformMatrix.matrix[12],
+      (CGFloat)transformMatrix.matrix[13],
+      (CGFloat)transformMatrix.matrix[14],
+      (CGFloat)transformMatrix.matrix[15]};
+}
+
+inline facebook::react::Point RCTPointFromCGPoint(const CGPoint &point)
+{
+  return {point.x, point.y};
+}
+
+inline facebook::react::Float RCTFloatFromCGFloat(CGFloat value)
+{
+  if (value == CGFLOAT_MAX) {
+    return std::numeric_limits<facebook::react::Float>::infinity();
+  }
+  return value;
+}
+
+inline facebook::react::Size RCTSizeFromCGSize(const CGSize &size)
+{
+  return {RCTFloatFromCGFloat(size.width), RCTFloatFromCGFloat(size.height)};
+}
+
+inline facebook::react::Rect RCTRectFromCGRect(const CGRect &rect)
+{
+  return {RCTPointFromCGPoint(rect.origin), RCTSizeFromCGSize(rect.size)};
+}
+
+inline facebook::react::EdgeInsets RCTEdgeInsetsFromUIEdgeInsets(const UIEdgeInsets &edgeInsets)
+{
+  return {edgeInsets.left, edgeInsets.top, edgeInsets.right, edgeInsets.bottom};
+}
+
+inline facebook::react::LayoutDirection RCTLayoutDirection(BOOL isRTL)
+{
+  return isRTL ? facebook::react::LayoutDirection::RightToLeft : facebook::react::LayoutDirection::LeftToRight;
+}
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTImageResponseDelegate.h

@@ -0,0 +1,20 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTImageResponseDelegate <NSObject>
+
+- (void)didReceiveImage:(UIImage *)image metadata:(id)metadata fromObserver:(const void *)observer;
+- (void)didReceiveProgress:(float)progress fromObserver:(const void *)observer;
+- (void)didReceiveFailureFromObserver:(const void *)observer;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTImageResponseObserverProxy.h

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#import "RCTImageResponseDelegate.h"
+
+#include <react/renderer/imagemanager/ImageResponseObserver.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace facebook::react {
+
+class RCTImageResponseObserverProxy final : public ImageResponseObserver {
+ public:
+  RCTImageResponseObserverProxy(id<RCTImageResponseDelegate> delegate = nil);
+
+  void didReceiveImage(const ImageResponse& imageResponse) const override;
+  void didReceiveProgress(float progress) const override;
+  void didReceiveFailure() const override;
+
+ private:
+  __weak id<RCTImageResponseDelegate> delegate_;
+};
+
+} // namespace facebook::react
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTImageResponseObserverProxy.mm

@@ -0,0 +1,51 @@
+/*
+ * 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 "RCTImageResponseObserverProxy.h"
+
+#import <React/RCTUtils.h>
+#import <react/renderer/imagemanager/ImageResponse.h>
+#import <react/renderer/imagemanager/ImageResponseObserver.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+namespace facebook::react {
+
+RCTImageResponseObserverProxy::RCTImageResponseObserverProxy(id<RCTImageResponseDelegate> delegate)
+    : delegate_(delegate)
+{
+}
+
+void RCTImageResponseObserverProxy::didReceiveImage(const ImageResponse &imageResponse) const
+{
+  UIImage *image = (UIImage *)unwrapManagedObject(imageResponse.getImage());
+  id metadata = unwrapManagedObject(imageResponse.getMetadata());
+  id<RCTImageResponseDelegate> delegate = delegate_;
+  auto this_ = this;
+  RCTExecuteOnMainQueue(^{
+    [delegate didReceiveImage:image metadata:metadata fromObserver:this_];
+  });
+}
+
+void RCTImageResponseObserverProxy::didReceiveProgress(float progress) const
+{
+  auto this_ = this;
+  id<RCTImageResponseDelegate> delegate = delegate_;
+  RCTExecuteOnMainQueue(^{
+    [delegate didReceiveProgress:progress fromObserver:this_];
+  });
+}
+
+void RCTImageResponseObserverProxy::didReceiveFailure() const
+{
+  auto this_ = this;
+  id<RCTImageResponseDelegate> delegate = delegate_;
+  RCTExecuteOnMainQueue(^{
+    [delegate didReceiveFailureFromObserver:this_];
+  });
+}
+
+} // namespace facebook::react

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTLocalizationProvider.h

@@ -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 <React/RCTDefines.h>
+#import <UIKit/UIKit.h>
+
+@protocol RCTLocalizationProtocol <NSObject>
+
+/*
+ Call for other apps to use their own translation functions
+ */
+- (NSString *)localizedString:(NSString *)oldString withDescription:(NSString *)description;
+
+@end
+
+/*
+ * It allows to set delegate for RCTLocalizationProvider so that we could ask APPs to do translations.
+ * It's an experimental feature.
+ */
+RCT_EXTERN void setLocalizationDelegate(id<RCTLocalizationProtocol> delegate);
+
+/*
+ * It allows apps to provide their translated language pack in case the cannot do translation reactively.
+ * It's an experimental feature.
+ */
+RCT_EXTERN void setLocalizationLanguagePack(NSDictionary<NSString *, NSString *> *pack);
+
+@interface RCTLocalizationProvider : NSObject
+
++ (NSString *)RCTLocalizedString:(NSString *)oldString withDescription:(NSString *)description;
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTLocalizationProvider.mm

@@ -0,0 +1,46 @@
+/*
+ * 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 "RCTLocalizationProvider.h"
+
+#import <Foundation/Foundation.h>
+
+static id<RCTLocalizationProtocol> _delegate = nil;
+static NSDictionary<NSString *, NSString *> *_languagePack = nil;
+
+void setLocalizationDelegate(id<RCTLocalizationProtocol> delegate)
+{
+  _delegate = delegate;
+}
+
+void setLocalizationLanguagePack(NSDictionary<NSString *, NSString *> *pack)
+{
+  _languagePack = pack;
+}
+
+@implementation RCTLocalizationProvider
+
++ (NSString *)RCTLocalizedString:(NSString *)oldString withDescription:(NSString *)description
+{
+  NSString *candidate = nil;
+
+  if (_delegate != nil) {
+    candidate = [_delegate localizedString:oldString withDescription:description];
+  }
+
+  if (candidate == nil && _languagePack != nil) {
+    candidate = _languagePack[oldString];
+  }
+
+  if (candidate == nil) {
+    candidate = oldString;
+  }
+
+  return candidate;
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTPrimitives.h

@@ -0,0 +1,10 @@
+/*
+ * 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 <Foundation/Foundation.h>
+
+typedef NSInteger ReactTag;

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTScheduler.h

@@ -0,0 +1,78 @@
+/*
+ * 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 <memory>
+
+#import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#import <react/renderer/core/ComponentDescriptor.h>
+#import <react/renderer/core/EventListener.h>
+#import <react/renderer/core/LayoutConstraints.h>
+#import <react/renderer/core/LayoutContext.h>
+#import <react/renderer/mounting/MountingCoordinator.h>
+#import <react/renderer/scheduler/SchedulerToolbox.h>
+#import <react/renderer/scheduler/SurfaceHandler.h>
+#import <react/renderer/uimanager/UIManager.h>
+#import <react/utils/ContextContainer.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTMountingManager;
+
+/**
+ * Exactly same semantic as `facebook::react::SchedulerDelegate`.
+ */
+@protocol RCTSchedulerDelegate
+
+- (void)schedulerDidFinishTransaction:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
+
+- (void)schedulerDidDispatchCommand:(const facebook::react::ShadowView &)shadowView
+                        commandName:(const std::string &)commandName
+                               args:(const folly::dynamic &)args;
+
+- (void)schedulerDidSendAccessibilityEvent:(const facebook::react::ShadowView &)shadowView
+                                 eventType:(const std::string &)eventType;
+
+- (void)schedulerDidSetIsJSResponder:(BOOL)isJSResponder
+                blockNativeResponder:(BOOL)blockNativeResponder
+                       forShadowView:(const facebook::react::ShadowView &)shadowView;
+
+@end
+
+/**
+ * `facebook::react::Scheduler` as an Objective-C class.
+ */
+@interface RCTScheduler : NSObject
+
+@property (atomic, weak, nullable) id<RCTSchedulerDelegate> delegate;
+@property (readonly) const std::shared_ptr<facebook::react::UIManager> uiManager;
+
+- (instancetype)initWithToolbox:(facebook::react::SchedulerToolbox)toolbox;
+
+- (void)registerSurface:(const facebook::react::SurfaceHandler &)surfaceHandler;
+- (void)unregisterSurface:(const facebook::react::SurfaceHandler &)surfaceHandler;
+
+- (const facebook::react::ComponentDescriptor *)findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN:
+    (facebook::react::ComponentHandle)handle;
+
+- (void)setupAnimationDriver:(const facebook::react::SurfaceHandler &)surfaceHandler;
+
+- (void)onAnimationStarted;
+
+- (void)onAllAnimationsComplete;
+
+- (void)animationTick;
+
+- (void)reportMount:(facebook::react::SurfaceId)surfaceId;
+
+- (void)addEventListener:(const std::shared_ptr<facebook::react::EventListener> &)listener;
+
+- (void)removeEventListener:(const std::shared_ptr<facebook::react::EventListener> &)listener;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTScheduler.mm

@@ -0,0 +1,198 @@
+/*
+ * 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 "RCTScheduler.h"
+
+#import <react/renderer/animations/LayoutAnimationDriver.h>
+#import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#import <react/renderer/debug/SystraceSection.h>
+#import <react/renderer/scheduler/Scheduler.h>
+#import <react/renderer/scheduler/SchedulerDelegate.h>
+#import <react/utils/RunLoopObserver.h>
+
+#import <React/RCTFollyConvert.h>
+
+#import "RCTConversions.h"
+
+using namespace facebook::react;
+
+class SchedulerDelegateProxy : public SchedulerDelegate {
+ public:
+  SchedulerDelegateProxy(void *scheduler) : scheduler_(scheduler) {}
+
+  void schedulerDidFinishTransaction(const MountingCoordinator::Shared &mountingCoordinator) override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler.delegate schedulerDidFinishTransaction:mountingCoordinator];
+  }
+
+  void schedulerDidRequestPreliminaryViewAllocation(SurfaceId surfaceId, const ShadowNode &shadowNode) override
+  {
+    // Does nothing.
+    // This delegate method is not currently used on iOS.
+  }
+
+  void schedulerDidDispatchCommand(
+      const ShadowView &shadowView,
+      const std::string &commandName,
+      const folly::dynamic &args) override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler.delegate schedulerDidDispatchCommand:shadowView commandName:commandName args:args];
+  }
+
+  void schedulerDidSetIsJSResponder(const ShadowView &shadowView, bool isJSResponder, bool blockNativeResponder)
+      override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler.delegate schedulerDidSetIsJSResponder:isJSResponder
+                                blockNativeResponder:blockNativeResponder
+                                       forShadowView:shadowView];
+  }
+
+  void schedulerDidSendAccessibilityEvent(const ShadowView &shadowView, const std::string &eventType) override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler.delegate schedulerDidSendAccessibilityEvent:shadowView eventType:eventType];
+  }
+
+ private:
+  void *scheduler_;
+};
+
+class LayoutAnimationDelegateProxy : public LayoutAnimationStatusDelegate, public RunLoopObserver::Delegate {
+ public:
+  LayoutAnimationDelegateProxy(void *scheduler) : scheduler_(scheduler) {}
+  virtual ~LayoutAnimationDelegateProxy() {}
+
+  void onAnimationStarted() override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler onAnimationStarted];
+  }
+
+  /**
+   * Called when the LayoutAnimation engine completes all pending animations.
+   */
+  void onAllAnimationsComplete() override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler onAllAnimationsComplete];
+  }
+
+  void activityDidChange(const RunLoopObserver::Delegate *delegate, RunLoopObserver::Activity activity)
+      const noexcept override
+  {
+    RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
+    [scheduler animationTick];
+  }
+
+ private:
+  void *scheduler_;
+};
+
+@implementation RCTScheduler {
+  std::unique_ptr<Scheduler> _scheduler;
+  std::shared_ptr<LayoutAnimationDriver> _animationDriver;
+  std::shared_ptr<SchedulerDelegateProxy> _delegateProxy;
+  std::shared_ptr<LayoutAnimationDelegateProxy> _layoutAnimationDelegateProxy;
+  RunLoopObserver::Unique _uiRunLoopObserver;
+}
+
+- (instancetype)initWithToolbox:(SchedulerToolbox)toolbox
+{
+  if (self = [super init]) {
+    auto reactNativeConfig =
+        toolbox.contextContainer->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
+
+    _delegateProxy = std::make_shared<SchedulerDelegateProxy>((__bridge void *)self);
+
+    if (reactNativeConfig->getBool("react_fabric:enabled_layout_animations_ios")) {
+      _layoutAnimationDelegateProxy = std::make_shared<LayoutAnimationDelegateProxy>((__bridge void *)self);
+      _animationDriver = std::make_shared<LayoutAnimationDriver>(
+          toolbox.runtimeExecutor, toolbox.contextContainer, _layoutAnimationDelegateProxy.get());
+      _uiRunLoopObserver =
+          toolbox.mainRunLoopObserverFactory(RunLoopObserver::Activity::BeforeWaiting, _layoutAnimationDelegateProxy);
+      _uiRunLoopObserver->setDelegate(_layoutAnimationDelegateProxy.get());
+    }
+
+    _scheduler = std::make_unique<Scheduler>(
+        toolbox, (_animationDriver ? _animationDriver.get() : nullptr), _delegateProxy.get());
+  }
+
+  return self;
+}
+
+- (void)animationTick
+{
+  _scheduler->animationTick();
+}
+
+- (void)reportMount:(facebook::react::SurfaceId)surfaceId
+{
+  _scheduler->reportMount(surfaceId);
+}
+
+- (void)dealloc
+{
+  if (_animationDriver) {
+    _animationDriver->setLayoutAnimationStatusDelegate(nullptr);
+  }
+
+  _scheduler->setDelegate(nullptr);
+}
+
+- (void)registerSurface:(const facebook::react::SurfaceHandler &)surfaceHandler
+{
+  _scheduler->registerSurface(surfaceHandler);
+}
+
+- (void)unregisterSurface:(const facebook::react::SurfaceHandler &)surfaceHandler
+{
+  _scheduler->unregisterSurface(surfaceHandler);
+}
+
+- (const ComponentDescriptor *)findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN:(ComponentHandle)handle
+{
+  return _scheduler->findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(handle);
+}
+
+- (void)setupAnimationDriver:(const facebook::react::SurfaceHandler &)surfaceHandler
+{
+  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(_animationDriver);
+}
+
+- (void)onAnimationStarted
+{
+  if (_uiRunLoopObserver) {
+    _uiRunLoopObserver->enable();
+  }
+}
+
+- (void)onAllAnimationsComplete
+{
+  if (_uiRunLoopObserver) {
+    _uiRunLoopObserver->disable();
+  }
+}
+
+- (void)addEventListener:(const std::shared_ptr<EventListener> &)listener
+{
+  return _scheduler->addEventListener(listener);
+}
+
+- (void)removeEventListener:(const std::shared_ptr<EventListener> &)listener
+{
+  return _scheduler->removeEventListener(listener);
+}
+
+- (const std::shared_ptr<facebook::react::UIManager>)uiManager
+{
+  return _scheduler->getUIManager();
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfacePointerHandler.h

@@ -0,0 +1,28 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTSurfacePointerHandler : UIGestureRecognizer
+
+/*
+ * Attaches (and detaches) a view to the touch handler.
+ * The receiver does not retain the provided view.
+ */
+- (void)attachToView:(UIView *)view;
+- (void)detachFromView:(UIView *)view;
+
+/*
+ * Offset of the attached view relative to the root component in points.
+ */
+@property (nonatomic, assign) CGPoint viewOriginOffset;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfacePointerHandler.mm

@@ -0,0 +1,771 @@
+/*
+ * 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 "RCTSurfacePointerHandler.h"
+
+#import <React/RCTIdentifierPool.h>
+#import <React/RCTReactTaggedView.h>
+#import <React/RCTUtils.h>
+#import <React/RCTViewComponentView.h>
+
+#import "RCTConversions.h"
+#import "RCTTouchableComponentViewProtocol.h"
+
+using namespace facebook::react;
+
+typedef NS_ENUM(NSInteger, RCTPointerEventType) {
+  RCTPointerEventTypeStart,
+  RCTPointerEventTypeMove,
+  RCTPointerEventTypeEnd,
+  RCTPointerEventTypeCancel,
+};
+
+static BOOL AllTouchesAreCancelledOrEnded(NSSet<UITouch *> *touches)
+{
+  for (UITouch *touch in touches) {
+    if (touch.phase == UITouchPhaseBegan || touch.phase == UITouchPhaseMoved || touch.phase == UITouchPhaseStationary) {
+      return NO;
+    }
+  }
+  return YES;
+}
+
+static BOOL AnyTouchesChanged(NSSet<UITouch *> *touches)
+{
+  for (UITouch *touch in touches) {
+    if (touch.phase == UITouchPhaseBegan || touch.phase == UITouchPhaseMoved) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+struct ActivePointer {
+  /*
+   * Pointer ID
+   */
+  NSInteger identifier;
+
+  /*
+   * The component view on which the touch started.
+   */
+  UIView<RCTComponentViewProtocol> *initialComponentView = nil;
+
+  /*
+   * The current target component view of the pointer
+   */
+  UIView<RCTComponentViewProtocol> *componentView = nil;
+
+  /*
+   * The location of the pointer relative to the root component view
+   */
+  CGPoint clientPoint;
+
+  /*
+   * The location of the pointer relative to the device's screen
+   */
+  CGPoint screenPoint;
+
+  /*
+   * The location of the pointer relative to the pointer's target
+   */
+  CGPoint offsetPoint;
+
+  /*
+   * Current timestamp of the pointer event
+   */
+  NSTimeInterval timestamp;
+
+  /*
+   * The current force of the pointer
+   */
+  Float force;
+
+  /*
+   * The type of touch received.
+   */
+  UITouchType touchType;
+
+  /*
+   * The radius (in points) of the touch.
+   */
+  CGFloat majorRadius;
+
+  /*
+   * The altitude (in radians) of the stylus.
+   */
+  CGFloat altitudeAngle;
+
+  /*
+   * The azimuth angle (in radians) of the stylus.
+   */
+  CGFloat azimuthAngle;
+
+  /*
+   * The button mask of the touch
+   */
+  UIEventButtonMask buttonMask;
+
+  /*
+   * The bit mask of modifier flags in the gesture represented by the receiver.
+   */
+  UIKeyModifierFlags modifierFlags;
+
+  /*
+   * Indicates if the active touch represents the primary pointer of this pointer type.
+   */
+  BOOL isPrimary;
+
+  /*
+   * The button number that was pressed (if applicable) when the event was fired.
+   */
+  NSInteger button;
+
+  /*
+   * Informs the event system that when the touch is released it should be treated as the
+   * pointer leaving the screen entirely.
+   */
+  BOOL shouldLeaveWhenReleased;
+
+  struct Hasher {
+    size_t operator()(const ActivePointer &activePointer) const
+    {
+      return std::hash<decltype(activePointer.identifier)>()(activePointer.identifier);
+    }
+  };
+
+  struct Comparator {
+    bool operator()(const ActivePointer &lhs, const ActivePointer &rhs) const
+    {
+      return lhs.identifier == rhs.identifier;
+    }
+  };
+};
+
+// Mouse and Pen pointers get reserved IDs so they stay consistent no matter the order
+// at which events come in
+static NSInteger constexpr kMousePointerId = 0;
+static NSInteger constexpr kPencilPointerId = 1;
+
+// If a new reserved ID is added above this should be incremented to ensure touch events
+// do not conflict
+static NSInteger constexpr kTouchIdentifierPoolOffset = 2;
+
+static SharedTouchEventEmitter GetTouchEmitterFromView(UIView *componentView, CGPoint point)
+{
+  return [(id<RCTTouchableComponentViewProtocol>)componentView touchEventEmitterAtPoint:point];
+}
+
+static NSOrderedSet<RCTReactTaggedView *> *GetTouchableViewsInPathToRoot(UIView *componentView)
+{
+  NSMutableOrderedSet *results = [NSMutableOrderedSet orderedSet];
+  do {
+    if ([componentView respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
+      [results addObject:[RCTReactTaggedView wrap:componentView]];
+    }
+    componentView = componentView.superview;
+  } while (componentView);
+  return results;
+}
+
+static UIView *FindClosestFabricManagedTouchableView(UIView *componentView)
+{
+  while (componentView) {
+    if ([componentView respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
+      return componentView;
+    }
+    componentView = componentView.superview;
+  }
+  return nil;
+}
+
+static NSInteger ButtonMaskDiffToButton(UIEventButtonMask prevButtonMask, UIEventButtonMask curButtonMask)
+{
+  if ((prevButtonMask & UIEventButtonMaskPrimary) != (curButtonMask & UIEventButtonMaskPrimary)) {
+    return 0;
+  }
+  if ((prevButtonMask & 0x4) != (curButtonMask & 0x4)) {
+    return 1;
+  }
+  if ((prevButtonMask & UIEventButtonMaskSecondary) != (curButtonMask & UIEventButtonMaskSecondary)) {
+    return 2;
+  }
+
+  return -1;
+}
+
+// Returns a CGPoint which represents the tiltX/Y values (in RADIANS)
+// Adapted from https://gist.github.com/k3a/2903719bb42b48c9198d20c2d6f73ac1
+static CGPoint SphericalToTilt(CGFloat altitudeAngleRad, CGFloat azimuthAngleRad)
+{
+  if (altitudeAngleRad == M_PI / 2.0) {
+    return CGPointMake(0.0, 0.0);
+  } else if (altitudeAngleRad == 0.0) {
+    // when pen is laying on the pad it is impossible to precisely encode but at least approximate for 4 cases
+    if (azimuthAngleRad > 7.0 * M_PI / 4.0 || azimuthAngleRad <= M_PI / 4.0) {
+      // for azimuthRad == 0, the pen is on the positive Y axis
+      return CGPointMake(0.0, M_PI / 2.0);
+    } else if (azimuthAngleRad > M_PI / 4.0 && azimuthAngleRad <= 3 * M_PI / 4.0) {
+      // for azimuthRad == math.pi/2 the pen is on the positive X axis
+      return CGPointMake(M_PI / 2.0, 0.0);
+    } else if (azimuthAngleRad > 3.0 * M_PI / 4.0 && azimuthAngleRad <= 5.0 * M_PI / 4.0) {
+      // for azimuthRad == math.pi, the pen is on the negative Y axis
+      return CGPointMake(0.0, -M_PI / 2.0);
+    } else if (azimuthAngleRad > 5.0 * M_PI / 4.0 && azimuthAngleRad <= 7.0 * M_PI / 4.0) {
+      // for azimuthRad == math.pi + math.pi/2 pen on negative X axis
+      return CGPointMake(-M_PI / 2.0, 0.0);
+    }
+  }
+
+  CGFloat tanAlt = tan(altitudeAngleRad); // tan(x) = sin(x)/cos(x)
+
+  CGFloat tiltXrad = atan(sin(azimuthAngleRad) / tanAlt);
+  CGFloat tiltYrad = atan(cos(azimuthAngleRad) / tanAlt);
+
+  return CGPointMake(tiltXrad, tiltYrad);
+}
+
+static CGFloat RadsToDegrees(CGFloat rads)
+{
+  return rads * 180 / M_PI;
+}
+
+static NSInteger ButtonMaskToButtons(UIEventButtonMask buttonMask)
+{
+  NSInteger buttonsMaskResult = 0;
+
+  if ((buttonMask & UIEventButtonMaskPrimary) != 0) {
+    buttonsMaskResult |= 1;
+  }
+  if ((buttonMask & UIEventButtonMaskSecondary) != 0) {
+    buttonsMaskResult |= 2;
+  }
+  // undocumented mask value which represents the "auxiliary button" (i.e. middle mouse button)
+  if ((buttonMask & 0x4) != 0) {
+    buttonsMaskResult |= 4;
+  }
+
+  return buttonsMaskResult;
+}
+
+static const char *PointerTypeCStringFromUITouchType(UITouchType type)
+{
+  switch (type) {
+    case UITouchTypeDirect:
+      return "touch";
+    case UITouchTypePencil:
+      return "pen";
+    case UITouchTypeIndirectPointer:
+      return "mouse";
+    case UITouchTypeIndirect:
+    default:
+      return "";
+  }
+}
+
+static void UpdatePointerEventModifierFlags(PointerEvent &event, UIKeyModifierFlags flags)
+{
+  event.ctrlKey = (flags & UIKeyModifierControl) != 0;
+  event.shiftKey = (flags & UIKeyModifierShift) != 0;
+  event.altKey = (flags & UIKeyModifierAlternate) != 0;
+  event.metaKey = (flags & UIKeyModifierCommand) != 0;
+}
+
+static PointerEvent CreatePointerEventFromActivePointer(
+    ActivePointer activePointer,
+    RCTPointerEventType eventType,
+    UIView *rootComponentView)
+{
+  PointerEvent event = {};
+  event.pointerId = activePointer.identifier;
+  event.pointerType = PointerTypeCStringFromUITouchType(activePointer.touchType);
+
+  if (eventType == RCTPointerEventTypeCancel) {
+    event.clientPoint = RCTPointFromCGPoint(CGPointZero);
+    event.screenPoint =
+        RCTPointFromCGPoint([rootComponentView convertPoint:CGPointZero
+                                          toCoordinateSpace:rootComponentView.window.screen.coordinateSpace]);
+    event.offsetPoint = RCTPointFromCGPoint([rootComponentView convertPoint:CGPointZero
+                                                                     toView:activePointer.componentView]);
+  } else {
+    event.clientPoint = RCTPointFromCGPoint(activePointer.clientPoint);
+    event.screenPoint = RCTPointFromCGPoint(activePointer.screenPoint);
+    event.offsetPoint = RCTPointFromCGPoint(activePointer.offsetPoint);
+  }
+
+  event.pressure = activePointer.force;
+
+  if (activePointer.touchType == UITouchTypeIndirectPointer) {
+    // pointer events with a mouse button pressed should report a pressure of 0.5
+    // when the touch is down and 0.0 when it is lifted regardless of how it is reported by the OS
+    event.pressure = eventType != RCTPointerEventTypeEnd ? 0.5 : 0.0;
+  }
+
+  CGFloat pointerSize = activePointer.majorRadius * 2.0;
+
+  if (activePointer.touchType == UITouchTypeIndirectPointer) {
+    // mouse type pointers should always report a size of 1
+    pointerSize = 1.0;
+  }
+
+  event.width = pointerSize;
+  event.height = pointerSize;
+
+  CGPoint tilt = SphericalToTilt(activePointer.altitudeAngle, activePointer.azimuthAngle);
+  event.tiltX = RadsToDegrees(tilt.x);
+  event.tiltY = RadsToDegrees(tilt.y);
+
+  event.detail = 0;
+
+  event.button = activePointer.button;
+  event.buttons = ButtonMaskToButtons(activePointer.buttonMask);
+
+  UpdatePointerEventModifierFlags(event, activePointer.modifierFlags);
+
+  event.tangentialPressure = 0.0;
+  event.twist = 0;
+  event.isPrimary = activePointer.isPrimary;
+
+  return event;
+}
+
+static PointerEvent CreatePointerEventFromIncompleteHoverData(
+    NSInteger pointerId,
+    std::string pointerType,
+    CGPoint clientLocation,
+    CGPoint screenLocation,
+    CGPoint offsetLocation,
+    UIKeyModifierFlags modifierFlags)
+{
+  PointerEvent event = {};
+  event.pointerId = pointerId;
+  event.pressure = 0.0;
+  event.pointerType = pointerType;
+  event.clientPoint = RCTPointFromCGPoint(clientLocation);
+  event.screenPoint = RCTPointFromCGPoint(screenLocation);
+  event.offsetPoint = RCTPointFromCGPoint(offsetLocation);
+  event.width = 1.0;
+  event.height = 1.0;
+  event.tiltX = 0;
+  event.tiltY = 0;
+  event.detail = 0;
+  event.button = -1;
+  event.buttons = 0;
+  UpdatePointerEventModifierFlags(event, modifierFlags);
+  event.tangentialPressure = 0.0;
+  event.twist = 0;
+  event.isPrimary = true;
+
+  return event;
+}
+
+static void UpdateActivePointerWithUITouch(
+    ActivePointer &activePointer,
+    UITouch *uiTouch,
+    UIEvent *uiEvent,
+    UIView *rootComponentView)
+{
+  CGPoint location = [uiTouch locationInView:rootComponentView];
+  UIView *hitTestedView = [rootComponentView hitTest:location withEvent:nil];
+  activePointer.componentView = FindClosestFabricManagedTouchableView(hitTestedView);
+
+  activePointer.clientPoint = [uiTouch locationInView:rootComponentView];
+  activePointer.screenPoint = [rootComponentView convertPoint:activePointer.clientPoint
+                                            toCoordinateSpace:rootComponentView.window.screen.coordinateSpace];
+  activePointer.offsetPoint = [uiTouch locationInView:activePointer.componentView];
+
+  activePointer.timestamp = uiTouch.timestamp;
+
+  activePointer.force = RCTZeroIfNaN(uiTouch.force / uiTouch.maximumPossibleForce);
+
+  activePointer.touchType = uiTouch.type;
+  activePointer.majorRadius = uiTouch.majorRadius;
+  activePointer.altitudeAngle = uiTouch.altitudeAngle;
+  activePointer.azimuthAngle = [uiTouch azimuthAngleInView:nil];
+
+  UIEventButtonMask nextButtonMask = 0;
+  if (uiTouch.phase != UITouchPhaseEnded) {
+    nextButtonMask = uiTouch.type == UITouchTypeIndirectPointer ? uiEvent.buttonMask : 1;
+  }
+  activePointer.button = ButtonMaskDiffToButton(activePointer.buttonMask, nextButtonMask);
+  activePointer.buttonMask = nextButtonMask;
+  activePointer.modifierFlags = uiEvent.modifierFlags;
+}
+
+/**
+ * Given an ActivePointer determine if it is still within the same event target tree as
+ * the one which initiated the pointer gesture.
+ */
+static BOOL IsPointerWithinInitialTree(ActivePointer activePointer)
+{
+  NSOrderedSet<RCTReactTaggedView *> *initialViewSet =
+      GetTouchableViewsInPathToRoot(activePointer.initialComponentView);
+  for (RCTReactTaggedView *canidateTaggedView in initialViewSet) {
+    if (canidateTaggedView.tag == activePointer.componentView.tag) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+/**
+ * Surprisingly, `__unsafe_unretained id` pointers are not regular pointers
+ * and `std::hash<>` cannot hash them.
+ * This is quite trivial but decent implementation of hasher function
+ * inspired by this research: https://stackoverflow.com/a/21062520/496389.
+ */
+template <typename PointerT>
+struct PointerHasher {
+  constexpr std::size_t operator()(const PointerT &value) const
+  {
+    return reinterpret_cast<size_t>(value);
+  }
+};
+
+@interface RCTSurfacePointerHandler () <UIGestureRecognizerDelegate>
+@end
+
+@implementation RCTSurfacePointerHandler {
+  std::unordered_map<__unsafe_unretained UITouch *, ActivePointer, PointerHasher<__unsafe_unretained UITouch *>>
+      _activePointers;
+
+  /*
+   * We hold the view weakly to prevent a retain cycle.
+   */
+  __weak UIView *_rootComponentView;
+  RCTIdentifierPool<11> _identifierPool;
+
+  UIHoverGestureRecognizer *_mouseHoverRecognizer API_AVAILABLE(ios(13.0));
+  UIHoverGestureRecognizer *_penHoverRecognizer API_AVAILABLE(ios(13.0));
+
+  NSMutableDictionary<NSNumber *, NSOrderedSet<RCTReactTaggedView *> *> *_currentlyHoveredViewsPerPointer;
+
+  NSInteger _primaryTouchPointerId;
+}
+
+- (instancetype)init
+{
+  if (self = [super initWithTarget:nil action:nil]) {
+    // `cancelsTouchesInView` and `delaysTouches*` are needed in order
+    // to be used as a top level event delegated recognizer.
+    // Otherwise, lower-level components not built using React Native,
+    // will fail to recognize gestures.
+    self.cancelsTouchesInView = NO;
+    self.delaysTouchesBegan = NO; // This is default value.
+    self.delaysTouchesEnded = NO;
+
+    self.delegate = self;
+
+    _mouseHoverRecognizer = nil;
+    _penHoverRecognizer = nil;
+    _currentlyHoveredViewsPerPointer = [[NSMutableDictionary alloc] init];
+    _primaryTouchPointerId = -1;
+  }
+
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)action)
+
+- (void)attachToView:(UIView *)view
+{
+  RCTAssert(self.view == nil, @"RCTSurfacePointerHandler already has an attached view.");
+
+  [view addGestureRecognizer:self];
+  _rootComponentView = view;
+
+  _mouseHoverRecognizer = [[UIHoverGestureRecognizer alloc] initWithTarget:self action:@selector(mouseHovering:)];
+  _mouseHoverRecognizer.allowedTouchTypes = @[ @(UITouchTypeIndirectPointer) ];
+  [view addGestureRecognizer:_mouseHoverRecognizer];
+
+  _penHoverRecognizer = [[UIHoverGestureRecognizer alloc] initWithTarget:self action:@selector(penHovering:)];
+  _penHoverRecognizer.allowedTouchTypes = @[ @(UITouchTypePencil) ];
+  [view addGestureRecognizer:_penHoverRecognizer];
+}
+
+- (void)detachFromView:(UIView *)view
+{
+  RCTAssertParam(view);
+  RCTAssert(self.view == view, @"RCTSufracePointerHandler attached to another view.");
+
+  [view removeGestureRecognizer:self];
+  _rootComponentView = nil;
+
+  if (_mouseHoverRecognizer != nil) {
+    [view removeGestureRecognizer:_mouseHoverRecognizer];
+    _mouseHoverRecognizer = nil;
+  }
+
+  if (_penHoverRecognizer != nil) {
+    [view removeGestureRecognizer:_penHoverRecognizer];
+    _penHoverRecognizer = nil;
+  }
+}
+
+#pragma mark - UITouch to ActivePointer management
+
+- (void)_registerTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  for (UITouch *touch in touches) {
+    ActivePointer activePointer = {};
+
+    // Determine the identifier of the Pointer and if it is the primary pointer
+
+    switch (touch.type) {
+      case UITouchTypeIndirectPointer:
+        activePointer.identifier = kMousePointerId;
+        activePointer.isPrimary = true;
+        break;
+      case UITouchTypePencil:
+        activePointer.identifier = kPencilPointerId;
+        activePointer.isPrimary = true;
+        break;
+      default:
+        // use the identifier pool offset to ensure no conflicts between the reserved IDs and the
+        // touch IDs
+        activePointer.identifier = _identifierPool.dequeue() + kTouchIdentifierPoolOffset;
+        if (_primaryTouchPointerId == -1) {
+          _primaryTouchPointerId = activePointer.identifier;
+          activePointer.isPrimary = true;
+        }
+        break;
+    }
+
+    // If the pointer has not been marked as hovering over views before the touch started, we register
+    // that the activeTouch should not maintain its hovered state once the pointer has been lifted.
+    auto currentlyHoveredViews = [_currentlyHoveredViewsPerPointer objectForKey:@(activePointer.identifier)];
+    if (currentlyHoveredViews == nil || [currentlyHoveredViews count] == 0) {
+      activePointer.shouldLeaveWhenReleased = YES;
+    }
+
+    activePointer.initialComponentView = FindClosestFabricManagedTouchableView(touch.view);
+
+    UpdateActivePointerWithUITouch(activePointer, touch, event, _rootComponentView);
+
+    _activePointers.emplace(touch, activePointer);
+  }
+}
+
+- (void)_updateTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  for (UITouch *touch in touches) {
+    auto iterator = _activePointers.find(touch);
+    RCTAssert(iterator != _activePointers.end(), @"Inconsistency between local and UIKit touch registries");
+    if (iterator == _activePointers.end()) {
+      continue;
+    }
+    UpdateActivePointerWithUITouch(iterator->second, touch, event, _rootComponentView);
+  }
+}
+
+- (void)_unregisterTouches:(NSSet<UITouch *> *)touches
+{
+  for (UITouch *touch in touches) {
+    auto iterator = _activePointers.find(touch);
+    RCTAssert(iterator != _activePointers.end(), @"Inconsistency between local and UIKit touch registries");
+    if (iterator == _activePointers.end()) {
+      continue;
+    }
+    auto &activePointer = iterator->second;
+
+    if (activePointer.identifier == _primaryTouchPointerId) {
+      _primaryTouchPointerId = -1;
+    }
+
+    // only need to enqueue if the touch type isn't one with a reserved identifier
+    switch (touch.type) {
+      case UITouchTypeIndirectPointer:
+      case UITouchTypePencil:
+        break;
+      default:
+        // since the touch's identifier has been offset we need to re-normalize it to 0-based
+        // which is what the identifier pool expects
+        _identifierPool.enqueue(activePointer.identifier - kTouchIdentifierPoolOffset);
+    }
+
+    _activePointers.erase(touch);
+  }
+}
+
+- (std::vector<ActivePointer>)_activePointersFromTouches:(NSSet<UITouch *> *)touches
+{
+  std::vector<ActivePointer> activePointers;
+  activePointers.reserve(touches.count);
+
+  for (UITouch *touch in touches) {
+    auto iterator = _activePointers.find(touch);
+    RCTAssert(iterator != _activePointers.end(), @"Inconsistency between local and UIKit touch registries");
+    if (iterator == _activePointers.end()) {
+      continue;
+    }
+    activePointers.push_back(iterator->second);
+  }
+
+  return activePointers;
+}
+
+- (void)_dispatchActivePointers:(std::vector<ActivePointer>)activePointers eventType:(RCTPointerEventType)eventType
+{
+  for (const auto &activePointer : activePointers) {
+    PointerEvent pointerEvent = CreatePointerEventFromActivePointer(activePointer, eventType, _rootComponentView);
+
+    SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(
+        activePointer.componentView,
+        [_rootComponentView convertPoint:activePointer.clientPoint toView:activePointer.componentView]);
+
+    if (eventEmitter != nil) {
+      switch (eventType) {
+        case RCTPointerEventTypeStart: {
+          eventEmitter->onPointerDown(pointerEvent);
+          break;
+        }
+        case RCTPointerEventTypeMove: {
+          eventEmitter->onPointerMove(pointerEvent);
+          break;
+        }
+        case RCTPointerEventTypeEnd: {
+          eventEmitter->onPointerUp(pointerEvent);
+          if (pointerEvent.isPrimary && pointerEvent.button == 0 && IsPointerWithinInitialTree(activePointer)) {
+            eventEmitter->onClick(pointerEvent);
+          }
+          break;
+        }
+        case RCTPointerEventTypeCancel: {
+          eventEmitter->onPointerCancel(pointerEvent);
+          break;
+        }
+      }
+    }
+  }
+}
+
+#pragma mark - `UIResponder`-ish touch-delivery methods
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+
+  [self _registerTouches:touches withEvent:event];
+  [self _dispatchActivePointers:[self _activePointersFromTouches:touches] eventType:RCTPointerEventTypeStart];
+
+  if (self.state == UIGestureRecognizerStatePossible) {
+    self.state = UIGestureRecognizerStateBegan;
+  } else if (self.state == UIGestureRecognizerStateBegan) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+
+  [self _updateTouches:touches withEvent:event];
+  [self _dispatchActivePointers:[self _activePointersFromTouches:touches] eventType:RCTPointerEventTypeMove];
+
+  self.state = UIGestureRecognizerStateChanged;
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+
+  [self _updateTouches:touches withEvent:event];
+  [self _dispatchActivePointers:[self _activePointersFromTouches:touches] eventType:RCTPointerEventTypeEnd];
+  [self _unregisterTouches:touches];
+
+  if (AllTouchesAreCancelledOrEnded(event.allTouches)) {
+    self.state = UIGestureRecognizerStateEnded;
+  } else if (AnyTouchesChanged(event.allTouches)) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+
+  [self _updateTouches:touches withEvent:event];
+  [self _dispatchActivePointers:[self _activePointersFromTouches:touches] eventType:RCTPointerEventTypeCancel];
+  [self _unregisterTouches:touches];
+
+  if (AllTouchesAreCancelledOrEnded(event.allTouches)) {
+    self.state = UIGestureRecognizerStateCancelled;
+  } else if (AnyTouchesChanged(event.allTouches)) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)reset
+{
+  [super reset];
+
+  if (!_activePointers.empty()) {
+    std::vector<ActivePointer> activePointers;
+    activePointers.reserve(_activePointers.size());
+
+    for (const auto &pair : _activePointers) {
+      activePointers.push_back(pair.second);
+    }
+
+    [self _dispatchActivePointers:activePointers eventType:RCTPointerEventTypeCancel];
+
+    // Force-unregistering all the pointers
+    _activePointers.clear();
+    _identifierPool.reset();
+  }
+}
+
+- (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)preventedGestureRecognizer
+{
+  return NO;
+}
+
+#pragma mark - Hover callbacks
+
+- (void)penHovering:(UIHoverGestureRecognizer *)recognizer API_AVAILABLE(ios(13.0))
+{
+  [self hovering:recognizer pointerId:kPencilPointerId pointerType:"pen"];
+}
+
+- (void)mouseHovering:(UIHoverGestureRecognizer *)recognizer API_AVAILABLE(ios(13.0))
+{
+  [self hovering:recognizer pointerId:kMousePointerId pointerType:"mouse"];
+}
+
+- (void)hovering:(UIHoverGestureRecognizer *)recognizer
+       pointerId:(int)pointerId
+     pointerType:(std::string)pointerType API_AVAILABLE(ios(13.0))
+{
+  UIView *listenerView = recognizer.view;
+  CGPoint clientLocation = [recognizer locationInView:listenerView];
+  CGPoint screenLocation = [listenerView convertPoint:clientLocation
+                                    toCoordinateSpace:listenerView.window.screen.coordinateSpace];
+
+  UIView *targetView = [listenerView hitTest:clientLocation withEvent:nil];
+  targetView = FindClosestFabricManagedTouchableView(targetView);
+
+  CGPoint offsetLocation = [recognizer locationInView:targetView];
+
+  UIKeyModifierFlags modifierFlags;
+
+  modifierFlags = recognizer.modifierFlags;
+
+  PointerEvent event = CreatePointerEventFromIncompleteHoverData(
+      pointerId, pointerType, clientLocation, screenLocation, offsetLocation, modifierFlags);
+
+  SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(targetView, offsetLocation);
+  if (eventEmitter != nil) {
+    switch (recognizer.state) {
+      case UIGestureRecognizerStateEnded:
+        eventEmitter->onPointerLeave(event);
+      default:
+        eventEmitter->onPointerMove(event);
+    }
+  }
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfacePresenter.h

@@ -0,0 +1,86 @@
+/*
+ * 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/RCTPrimitives.h>
+#import <React/RCTSurfacePresenterStub.h>
+#import <React/RCTSurfaceStage.h>
+#import <ReactCommon/RuntimeExecutor.h>
+#import <react/renderer/scheduler/SurfaceHandler.h>
+#import <react/utils/ContextContainer.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTFabricSurface;
+@class RCTImageLoader;
+@class RCTMountingManager;
+@class RCTScheduler;
+
+/**
+ * Coordinates presenting of React Native Surfaces and represents application
+ * facing interface of running React Native core.
+ */
+@interface RCTSurfacePresenter : NSObject
+
+- (instancetype)initWithContextContainer:(facebook::react::ContextContainer::Shared)contextContainer
+                         runtimeExecutor:(facebook::react::RuntimeExecutor)runtimeExecutor
+              bridgelessBindingsExecutor:(std::optional<facebook::react::RuntimeExecutor>)bridgelessBindingsExecutor;
+
+@property (nonatomic) facebook::react::ContextContainer::Shared contextContainer;
+@property (nonatomic) facebook::react::RuntimeExecutor runtimeExecutor;
+
+/*
+ * Suspends/resumes all surfaces associated with the presenter.
+ * Suspending is a process or graceful stopping all surfaces and destroying all underlying infrastructure
+ * with a future possibility of recreating the infrastructure and restarting the surfaces from scratch.
+ * Suspending is usually a part of a bundle reloading process.
+ * Can be called on any thread.
+ */
+- (BOOL)suspend;
+- (BOOL)resume;
+
+@end
+
+@interface RCTSurfacePresenter (Surface) <RCTSurfacePresenterStub>
+
+/*
+ * Surface uses these methods to register itself in the Presenter.
+ */
+- (void)registerSurface:(RCTFabricSurface *)surface;
+- (void)unregisterSurface:(RCTFabricSurface *)surface;
+
+@property (readonly) RCTMountingManager *mountingManager;
+@property (readonly, nullable) RCTScheduler *scheduler;
+
+/*
+ * Allow callers to initialize a new fabric surface without adding Fabric as a Buck dependency.
+ */
+- (id<RCTSurfaceProtocol>)createFabricSurfaceForModuleName:(NSString *)moduleName
+                                         initialProperties:(NSDictionary *)initialProperties;
+
+- (nullable RCTFabricSurface *)surfaceForRootTag:(ReactTag)rootTag;
+
+- (BOOL)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag props:(NSDictionary *)props;
+
+- (void)setupAnimationDriverWithSurfaceHandler:(const facebook::react::SurfaceHandler &)surfaceHandler;
+
+/*
+ * Deprecated.
+ * Use `RCTMountingTransactionObserverCoordinator` instead.
+ */
+- (void)addObserver:(id<RCTSurfacePresenterObserver>)observer;
+- (void)removeObserver:(id<RCTSurfacePresenterObserver>)observer;
+
+/*
+ * Please do not use this, this will be deleted soon.
+ */
+- (nullable UIView *)findComponentViewWithTag_DO_NOT_USE_DEPRECATED:(NSInteger)tag;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfacePresenter.mm

@@ -0,0 +1,461 @@
+/*
+ * 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 "RCTSurfacePresenter.h"
+
+#import <mutex>
+#import <shared_mutex>
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/RCTComponentViewRegistry.h>
+#import <React/RCTConstants.h>
+#import <React/RCTFabricSurface.h>
+#import <React/RCTFollyConvert.h>
+#import <React/RCTI18nUtil.h>
+#import <React/RCTMountingManager.h>
+#import <React/RCTMountingManagerDelegate.h>
+#import <React/RCTScheduler.h>
+#import <React/RCTSurfaceRegistry.h>
+#import <React/RCTSurfaceView+Internal.h>
+#import <React/RCTSurfaceView.h>
+#import <React/RCTUtils.h>
+
+#import <react/config/ReactNativeConfig.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#import <react/renderer/components/text/BaseTextProps.h>
+#import <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#import <react/renderer/scheduler/AsynchronousEventBeat.h>
+#import <react/renderer/scheduler/SchedulerToolbox.h>
+#import <react/renderer/scheduler/SynchronousEventBeat.h>
+#import <react/utils/ContextContainer.h>
+#import <react/utils/CoreFeatures.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+#import "PlatformRunLoopObserver.h"
+#import "RCTConversions.h"
+
+using namespace facebook;
+using namespace facebook::react;
+
+static dispatch_queue_t RCTGetBackgroundQueue()
+{
+  static dispatch_queue_t queue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    dispatch_queue_attr_t attr =
+        dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INTERACTIVE, 0);
+    queue = dispatch_queue_create("com.facebook.react.background", attr);
+  });
+  return queue;
+}
+
+static BackgroundExecutor RCTGetBackgroundExecutor()
+{
+  return [](std::function<void()> &&callback) {
+    if (RCTIsMainQueue()) {
+      callback();
+      return;
+    }
+
+    auto copyableCallback = callback;
+    dispatch_async(RCTGetBackgroundQueue(), ^{
+      copyableCallback();
+    });
+  };
+}
+
+@interface RCTSurfacePresenter () <RCTSchedulerDelegate, RCTMountingManagerDelegate>
+@end
+
+@implementation RCTSurfacePresenter {
+  RCTMountingManager *_mountingManager; // Thread-safe.
+  RCTSurfaceRegistry *_surfaceRegistry; // Thread-safe.
+
+  std::mutex _schedulerAccessMutex;
+  std::mutex _schedulerLifeCycleMutex;
+  RCTScheduler *_Nullable _scheduler; // Thread-safe. Pointer is protected by `_schedulerAccessMutex`.
+  ContextContainer::Shared _contextContainer; // Protected by `_schedulerLifeCycleMutex`.
+  RuntimeExecutor _runtimeExecutor; // Protected by `_schedulerLifeCycleMutex`.
+  std::optional<RuntimeExecutor> _bridgelessBindingsExecutor; // Only used for installing bindings.
+
+  std::shared_mutex _observerListMutex;
+  std::vector<__weak id<RCTSurfacePresenterObserver>> _observers; // Protected by `_observerListMutex`.
+}
+
+- (instancetype)initWithContextContainer:(ContextContainer::Shared)contextContainer
+                         runtimeExecutor:(RuntimeExecutor)runtimeExecutor
+              bridgelessBindingsExecutor:(std::optional<RuntimeExecutor>)bridgelessBindingsExecutor
+{
+  if (self = [super init]) {
+    assert(contextContainer && "RuntimeExecutor must be not null.");
+    _runtimeExecutor = runtimeExecutor;
+    _bridgelessBindingsExecutor = bridgelessBindingsExecutor;
+    _contextContainer = contextContainer;
+
+    _surfaceRegistry = [RCTSurfaceRegistry new];
+    _mountingManager = [RCTMountingManager new];
+    _mountingManager.contextContainer = contextContainer;
+    _mountingManager.delegate = self;
+
+    _scheduler = [self _createScheduler];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(_applicationWillTerminate)
+                                                 name:UIApplicationWillTerminateNotification
+                                               object:nil];
+  }
+
+  return self;
+}
+
+- (RCTMountingManager *)mountingManager
+{
+  return _mountingManager;
+}
+
+- (RCTScheduler *_Nullable)scheduler
+{
+  std::lock_guard<std::mutex> lock(_schedulerAccessMutex);
+  return _scheduler;
+}
+
+- (ContextContainer::Shared)contextContainer
+{
+  std::lock_guard<std::mutex> lock(_schedulerLifeCycleMutex);
+  return _contextContainer;
+}
+
+- (void)setRuntimeExecutor:(RuntimeExecutor)runtimeExecutor
+{
+  std::lock_guard<std::mutex> lock(_schedulerLifeCycleMutex);
+  _runtimeExecutor = runtimeExecutor;
+}
+
+#pragma mark - Internal Surface-dedicated Interface
+
+- (void)registerSurface:(RCTFabricSurface *)surface
+{
+  [_surfaceRegistry registerSurface:surface];
+  RCTScheduler *scheduler = [self scheduler];
+  if (scheduler) {
+    [scheduler registerSurface:surface.surfaceHandler];
+  }
+}
+
+- (void)unregisterSurface:(RCTFabricSurface *)surface
+{
+  RCTScheduler *scheduler = [self scheduler];
+  if (scheduler) {
+    [scheduler unregisterSurface:surface.surfaceHandler];
+  }
+  [_surfaceRegistry unregisterSurface:surface];
+}
+
+- (RCTFabricSurface *)surfaceForRootTag:(ReactTag)rootTag
+{
+  return [_surfaceRegistry surfaceForRootTag:rootTag];
+}
+
+- (id<RCTSurfaceProtocol>)createFabricSurfaceForModuleName:(NSString *)moduleName
+                                         initialProperties:(NSDictionary *)initialProperties
+{
+  return [[RCTFabricSurface alloc] initWithSurfacePresenter:self
+                                                 moduleName:moduleName
+                                          initialProperties:initialProperties];
+}
+
+- (UIView *)findComponentViewWithTag_DO_NOT_USE_DEPRECATED:(NSInteger)tag
+{
+  UIView<RCTComponentViewProtocol> *componentView =
+      [_mountingManager.componentViewRegistry findComponentViewWithTag:tag];
+  return componentView;
+}
+
+- (BOOL)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag props:(NSDictionary *)props
+{
+  RCTScheduler *scheduler = [self scheduler];
+  if (!scheduler) {
+    return NO;
+  }
+
+  ReactTag tag = [reactTag integerValue];
+  UIView<RCTComponentViewProtocol> *componentView =
+      [_mountingManager.componentViewRegistry findComponentViewWithTag:tag];
+  if (componentView == nil) {
+    return NO; // This view probably isn't managed by Fabric
+  }
+  ComponentHandle handle = [[componentView class] componentDescriptorProvider].handle;
+  auto *componentDescriptor = [scheduler findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN:handle];
+
+  if (!componentDescriptor) {
+    return YES;
+  }
+
+  [_mountingManager synchronouslyUpdateViewOnUIThread:tag changedProps:props componentDescriptor:*componentDescriptor];
+  return YES;
+}
+
+- (void)setupAnimationDriverWithSurfaceHandler:(const facebook::react::SurfaceHandler &)surfaceHandler
+{
+  [[self scheduler] setupAnimationDriver:surfaceHandler];
+}
+
+- (BOOL)suspend
+{
+  std::lock_guard<std::mutex> lock(_schedulerLifeCycleMutex);
+
+  RCTScheduler *scheduler;
+  {
+    std::lock_guard<std::mutex> accessLock(_schedulerAccessMutex);
+
+    if (!_scheduler) {
+      return NO;
+    }
+    scheduler = _scheduler;
+    _scheduler = nil;
+  }
+
+  [self _stopAllSurfacesWithScheduler:scheduler];
+
+  return YES;
+}
+
+- (BOOL)resume
+{
+  std::lock_guard<std::mutex> lock(_schedulerLifeCycleMutex);
+
+  RCTScheduler *scheduler;
+  {
+    std::lock_guard<std::mutex> accessLock(_schedulerAccessMutex);
+
+    if (_scheduler) {
+      return NO;
+    }
+    scheduler = [self _createScheduler];
+  }
+
+  [self _startAllSurfacesWithScheduler:scheduler];
+
+  {
+    std::lock_guard<std::mutex> accessLock(_schedulerAccessMutex);
+    _scheduler = scheduler;
+  }
+
+  return YES;
+}
+
+#pragma mark - Private
+
+- (RCTScheduler *)_createScheduler
+{
+  auto reactNativeConfig = _contextContainer->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
+
+  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_cpp_props_iterator_setter_ios")) {
+    CoreFeatures::enablePropIteratorSetter = true;
+  }
+
+  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_granular_scroll_view_state_updates_ios")) {
+    CoreFeatures::enableGranularScrollViewStateUpdatesIOS = true;
+  }
+
+  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_mount_hooks_ios")) {
+    CoreFeatures::enableMountHooks = true;
+  }
+
+  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_cloneless_state_progression")) {
+    CoreFeatures::enableClonelessStateProgression = true;
+  }
+
+  auto componentRegistryFactory =
+      [factory = wrapManagedObject(_mountingManager.componentViewRegistry.componentViewFactory)](
+          const EventDispatcher::Weak &eventDispatcher, const ContextContainer::Shared &contextContainer) {
+        return [(RCTComponentViewFactory *)unwrapManagedObject(factory)
+            createComponentDescriptorRegistryWithParameters:{eventDispatcher, contextContainer}];
+      };
+
+  auto runtimeExecutor = _runtimeExecutor;
+
+  auto toolbox = SchedulerToolbox{};
+  toolbox.contextContainer = _contextContainer;
+  toolbox.componentRegistryFactory = componentRegistryFactory;
+
+  auto weakRuntimeScheduler = _contextContainer->find<std::weak_ptr<RuntimeScheduler>>("RuntimeScheduler");
+  auto runtimeScheduler = weakRuntimeScheduler.has_value() ? weakRuntimeScheduler.value().lock() : nullptr;
+  if (runtimeScheduler) {
+    runtimeExecutor = [runtimeScheduler](std::function<void(jsi::Runtime & runtime)> &&callback) {
+      runtimeScheduler->scheduleWork(std::move(callback));
+    };
+  }
+
+  toolbox.runtimeExecutor = runtimeExecutor;
+  toolbox.bridgelessBindingsExecutor = _bridgelessBindingsExecutor;
+
+  toolbox.mainRunLoopObserverFactory = [](RunLoopObserver::Activity activities,
+                                          const RunLoopObserver::WeakOwner &owner) {
+    return std::make_unique<MainRunLoopObserver>(activities, owner);
+  };
+
+  if (ReactNativeFeatureFlags::enableBackgroundExecutor()) {
+    toolbox.backgroundExecutor = RCTGetBackgroundExecutor();
+  }
+
+  toolbox.synchronousEventBeatFactory =
+      [runtimeExecutor, runtimeScheduler = runtimeScheduler](const EventBeat::SharedOwnerBox &ownerBox) {
+        auto runLoopObserver =
+            std::make_unique<MainRunLoopObserver const>(RunLoopObserver::Activity::BeforeWaiting, ownerBox->owner);
+        return std::make_unique<SynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor, runtimeScheduler);
+      };
+
+  toolbox.asynchronousEventBeatFactory =
+      [runtimeExecutor](const EventBeat::SharedOwnerBox &ownerBox) -> std::unique_ptr<EventBeat> {
+    auto runLoopObserver =
+        std::make_unique<MainRunLoopObserver const>(RunLoopObserver::Activity::BeforeWaiting, ownerBox->owner);
+    return std::make_unique<AsynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor);
+  };
+
+  RCTScheduler *scheduler = [[RCTScheduler alloc] initWithToolbox:toolbox];
+  scheduler.delegate = self;
+
+  return scheduler;
+}
+
+- (void)_startAllSurfacesWithScheduler:(RCTScheduler *)scheduler
+{
+  [_surfaceRegistry enumerateWithBlock:^(NSEnumerator<RCTFabricSurface *> *enumerator) {
+    for (RCTFabricSurface *surface in enumerator) {
+      [scheduler registerSurface:surface.surfaceHandler];
+      [surface start];
+    }
+  }];
+}
+
+- (void)_stopAllSurfacesWithScheduler:(RCTScheduler *)scheduler
+{
+  [_surfaceRegistry enumerateWithBlock:^(NSEnumerator<RCTFabricSurface *> *enumerator) {
+    for (RCTFabricSurface *surface in enumerator) {
+      [surface stop];
+      [scheduler unregisterSurface:surface.surfaceHandler];
+    }
+  }];
+}
+
+- (void)_applicationWillTerminate
+{
+  [self suspend];
+}
+
+#pragma mark - RCTSchedulerDelegate
+
+- (void)schedulerDidFinishTransaction:(MountingCoordinator::Shared)mountingCoordinator
+{
+  [_mountingManager scheduleTransaction:mountingCoordinator];
+}
+
+- (void)schedulerDidDispatchCommand:(const ShadowView &)shadowView
+                        commandName:(const std::string &)commandName
+                               args:(const folly::dynamic &)args
+{
+  ReactTag tag = shadowView.tag;
+  NSString *commandStr = [[NSString alloc] initWithUTF8String:commandName.c_str()];
+  NSArray *argsArray = convertFollyDynamicToId(args);
+
+  [_mountingManager dispatchCommand:tag commandName:commandStr args:argsArray];
+}
+
+- (void)schedulerDidSendAccessibilityEvent:(const facebook::react::ShadowView &)shadowView
+                                 eventType:(const std::string &)eventType
+{
+  ReactTag tag = shadowView.tag;
+  NSString *eventTypeStr = [[NSString alloc] initWithUTF8String:eventType.c_str()];
+
+  [_mountingManager sendAccessibilityEvent:tag eventType:eventTypeStr];
+}
+
+- (void)schedulerDidSetIsJSResponder:(BOOL)isJSResponder
+                blockNativeResponder:(BOOL)blockNativeResponder
+                       forShadowView:(const facebook::react::ShadowView &)shadowView;
+{
+  [_mountingManager setIsJSResponder:isJSResponder blockNativeResponder:blockNativeResponder forShadowView:shadowView];
+}
+
+- (void)addObserver:(id<RCTSurfacePresenterObserver>)observer
+{
+  std::unique_lock lock(_observerListMutex);
+  _observers.push_back(observer);
+}
+
+- (void)removeObserver:(id<RCTSurfacePresenterObserver>)observer
+{
+  std::unique_lock lock(_observerListMutex);
+  std::vector<__weak id<RCTSurfacePresenterObserver>>::const_iterator it =
+      std::find(_observers.begin(), _observers.end(), observer);
+  if (it != _observers.end()) {
+    _observers.erase(it);
+  }
+}
+
+#pragma mark - RCTMountingManagerDelegate
+
+- (void)mountingManager:(RCTMountingManager *)mountingManager willMountComponentsWithRootTag:(ReactTag)rootTag
+{
+  RCTAssertMainQueue();
+
+  NSArray<id<RCTSurfacePresenterObserver>> *observersCopy;
+  {
+    std::shared_lock lock(_observerListMutex);
+    observersCopy = [self _getObservers];
+  }
+
+  for (id<RCTSurfacePresenterObserver> observer in observersCopy) {
+    if ([observer respondsToSelector:@selector(willMountComponentsWithRootTag:)]) {
+      [observer willMountComponentsWithRootTag:rootTag];
+    }
+  }
+}
+
+- (void)mountingManager:(RCTMountingManager *)mountingManager didMountComponentsWithRootTag:(ReactTag)rootTag
+{
+  RCTAssertMainQueue();
+
+  NSArray<id<RCTSurfacePresenterObserver>> *observersCopy;
+  {
+    std::shared_lock lock(_observerListMutex);
+    observersCopy = [self _getObservers];
+  }
+
+  for (id<RCTSurfacePresenterObserver> observer in observersCopy) {
+    if ([observer respondsToSelector:@selector(didMountComponentsWithRootTag:)]) {
+      [observer didMountComponentsWithRootTag:rootTag];
+    }
+  }
+
+  RCTScheduler *scheduler = [self scheduler];
+  if (scheduler) {
+    // Notify mount when the effects are visible and prevent mount hooks to
+    // delay paint.
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [scheduler reportMount:rootTag];
+    });
+  }
+}
+
+- (NSArray<id<RCTSurfacePresenterObserver>> *)_getObservers
+{
+  NSMutableArray<id<RCTSurfacePresenterObserver>> *observersCopy = [NSMutableArray new];
+  for (id<RCTSurfacePresenterObserver> observer : _observers) {
+    if (observer) {
+      [observersCopy addObject:observer];
+    }
+  }
+
+  return observersCopy;
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfacePresenterBridgeAdapter.h

@@ -0,0 +1,43 @@
+/*
+ * 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 <Foundation/Foundation.h>
+#import <ReactCommon/RuntimeExecutor.h>
+#import <UIKit/UIKit.h>
+#import <react/utils/ContextContainer.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTSurfacePresenter;
+@class RCTBridge;
+
+facebook::react::RuntimeExecutor RCTRuntimeExecutorFromBridge(RCTBridge *bridge);
+
+/*
+ * Controls a life-cycle of a Surface Presenter based on Bridge's life-cycle.
+ * We are moving away from using Bridge.
+ * This class is intended to be used only during the transition period.
+ */
+@interface RCTSurfacePresenterBridgeAdapter : NSObject
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+              contextContainer:(facebook::react::ContextContainer::Shared)contextContainer;
+
+/*
+ * Returns a stored instance of Surface Presenter which is managed by a bridge.
+ */
+@property (nonatomic, readonly) RCTSurfacePresenter *surfacePresenter;
+
+/*
+ * Controls a stored instance of the Bridge. A consumer can re-set the stored Bridge using that method; the class is
+ * responsible to coordinate this change with a SurfacePresenter accordingly.
+ */
+@property (nonatomic, weak) RCTBridge *bridge;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfacePresenterBridgeAdapter.mm

@@ -0,0 +1,204 @@
+/*
+ * 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 "RCTSurfacePresenterBridgeAdapter.h"
+
+#import <cxxreact/MessageQueueThread.h>
+#import <jsi/jsi.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTConstants.h>
+#import <React/RCTImageLoader.h>
+#import <React/RCTImageLoaderWithAttributionProtocol.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfacePresenterStub.h>
+
+#import <ReactCommon/RuntimeExecutor.h>
+#import <react/utils/ContextContainer.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+using namespace facebook::react;
+
+@interface RCTBridge ()
+- (std::shared_ptr<facebook::react::MessageQueueThread>)jsMessageThread;
+- (void)invokeAsync:(std::function<void()> &&)func;
+@end
+
+static ContextContainer::Shared RCTContextContainerFromBridge(RCTBridge *bridge)
+{
+  auto contextContainer = std::make_shared<const ContextContainer>();
+
+  RCTImageLoader *imageLoader = RCTTurboModuleEnabled()
+      ? [bridge moduleForName:@"RCTImageLoader" lazilyLoadIfNecessary:YES]
+      : [bridge moduleForClass:[RCTImageLoader class]];
+
+  contextContainer->insert("Bridge", wrapManagedObjectWeakly(bridge));
+  contextContainer->insert("RCTImageLoader", wrapManagedObject((id<RCTImageLoaderWithAttributionProtocol>)imageLoader));
+  return contextContainer;
+}
+
+RuntimeExecutor RCTRuntimeExecutorFromBridge(RCTBridge *bridge)
+{
+  RCTAssert(bridge, @"RCTRuntimeExecutorFromBridge: Bridge must not be nil.");
+
+  auto bridgeWeakWrapper = wrapManagedObjectWeakly([bridge batchedBridge] ?: bridge);
+
+  RuntimeExecutor runtimeExecutor = [bridgeWeakWrapper](
+                                        std::function<void(facebook::jsi::Runtime & runtime)> &&callback) {
+    RCTBridge *bridge = unwrapManagedObjectWeakly(bridgeWeakWrapper);
+
+    RCTAssert(bridge, @"RCTRuntimeExecutorFromBridge: Bridge must not be nil at the moment of scheduling a call.");
+
+    [bridge invokeAsync:[bridgeWeakWrapper, callback = std::move(callback)]() {
+      RCTCxxBridge *batchedBridge = (RCTCxxBridge *)unwrapManagedObjectWeakly(bridgeWeakWrapper);
+
+      RCTAssert(batchedBridge, @"RCTRuntimeExecutorFromBridge: Bridge must not be nil at the moment of invocation.");
+
+      if (!batchedBridge) {
+        return;
+      }
+
+      auto runtime = (facebook::jsi::Runtime *)(batchedBridge.runtime);
+
+      RCTAssert(
+          runtime, @"RCTRuntimeExecutorFromBridge: Bridge must have a valid jsi::Runtime at the moment of invocation.");
+
+      if (!runtime) {
+        return;
+      }
+
+      callback(*runtime);
+    }];
+  };
+
+  return runtimeExecutor;
+}
+
+@implementation RCTSurfacePresenterBridgeAdapter {
+  RCTSurfacePresenter *_Nullable _surfacePresenter;
+  __weak RCTBridge *_bridge;
+  __weak RCTBridge *_batchedBridge;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge contextContainer:(ContextContainer::Shared)contextContainer
+{
+  if (self = [super init]) {
+    contextContainer->update(*RCTContextContainerFromBridge(bridge));
+    _surfacePresenter = [[RCTSurfacePresenter alloc] initWithContextContainer:contextContainer
+                                                              runtimeExecutor:RCTRuntimeExecutorFromBridge(bridge)
+                                                   bridgelessBindingsExecutor:std::nullopt];
+
+    _bridge = bridge;
+    _batchedBridge = [_bridge batchedBridge] ?: _bridge;
+
+    [self _updateSurfacePresenter];
+    [self _addBridgeObservers:_bridge];
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  [_surfacePresenter suspend];
+}
+
+- (RCTBridge *)bridge
+{
+  return _bridge;
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  if (bridge == _bridge) {
+    return;
+  }
+
+  [self _removeBridgeObservers:_bridge];
+
+  [_surfacePresenter suspend];
+
+  _bridge = bridge;
+  _batchedBridge = [_bridge batchedBridge] ?: _bridge;
+
+  [self _updateSurfacePresenter];
+
+  [self _addBridgeObservers:_bridge];
+
+  [_surfacePresenter resume];
+}
+
+- (void)_updateSurfacePresenter
+{
+  _surfacePresenter.runtimeExecutor = RCTRuntimeExecutorFromBridge(_bridge);
+  _surfacePresenter.contextContainer->update(*RCTContextContainerFromBridge(_bridge));
+
+  [_bridge setSurfacePresenter:_surfacePresenter];
+  [_batchedBridge setSurfacePresenter:_surfacePresenter];
+}
+
+- (void)_addBridgeObservers:(RCTBridge *)bridge
+{
+  if (!bridge) {
+    return;
+  }
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleBridgeWillReloadNotification:)
+                                               name:RCTBridgeWillReloadNotification
+                                             object:bridge];
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleJavaScriptDidLoadNotification:)
+                                               name:RCTJavaScriptDidLoadNotification
+                                             object:bridge];
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleBridgeWillBeInvalidatedNotification:)
+                                               name:RCTBridgeWillBeInvalidatedNotification
+                                             object:bridge];
+}
+
+- (void)_removeBridgeObservers:(RCTBridge *)bridge
+{
+  if (!bridge) {
+    return;
+  }
+
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:RCTBridgeWillReloadNotification object:bridge];
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:RCTJavaScriptDidLoadNotification object:bridge];
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:RCTBridgeWillBeInvalidatedNotification object:bridge];
+}
+
+#pragma mark - Bridge events
+
+- (void)handleBridgeWillReloadNotification:(NSNotification *)notification
+{
+  [_surfacePresenter suspend];
+}
+
+- (void)handleBridgeWillBeInvalidatedNotification:(NSNotification *)notification
+{
+  [_surfacePresenter suspend];
+}
+
+- (void)handleJavaScriptDidLoadNotification:(NSNotification *)notification
+{
+  RCTBridge *bridge = notification.userInfo[@"bridge"];
+  if (bridge == _batchedBridge) {
+    // Nothing really changed.
+    return;
+  }
+
+  _batchedBridge = bridge;
+  _batchedBridge.surfacePresenter = _surfacePresenter;
+
+  [self _updateSurfacePresenter];
+
+  [_surfacePresenter resume];
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfaceRegistry.h

@@ -0,0 +1,47 @@
+/*
+ * 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/RCTPrimitives.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTFabricSurface;
+
+typedef void (^RCTSurfaceEnumeratorBlock)(NSEnumerator<RCTFabricSurface *> *enumerator);
+
+/**
+ * Registry of Surfaces.
+ * Encapsulates storing Surface objects and querying them by root tag.
+ * All methods of the registry are thread-safe.
+ * The registry stores Surface objects as weak references.
+ */
+@interface RCTSurfaceRegistry : NSObject
+
+- (void)enumerateWithBlock:(RCTSurfaceEnumeratorBlock)block;
+
+/**
+ * Adds Surface object into the registry.
+ * The registry does not retain Surface references.
+ */
+- (void)registerSurface:(RCTFabricSurface *)surface;
+
+/**
+ * Removes Surface object from the registry.
+ */
+- (void)unregisterSurface:(RCTFabricSurface *)surface;
+
+/**
+ * Returns stored Surface object by given root tag.
+ * If the registry does not have such Surface registered, returns `nil`.
+ */
+- (nullable RCTFabricSurface *)surfaceForRootTag:(ReactTag)rootTag;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfaceRegistry.mm

@@ -0,0 +1,61 @@
+/*
+ * 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 "RCTSurfaceRegistry.h"
+
+#import <mutex>
+#import <shared_mutex>
+
+#import <React/RCTFabricSurface.h>
+
+using namespace facebook;
+
+@implementation RCTSurfaceRegistry {
+  std::shared_mutex _mutex;
+  NSMapTable<id, RCTFabricSurface *> *_registry;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _registry = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsIntegerPersonality | NSPointerFunctionsOpaqueMemory
+                                      valueOptions:NSPointerFunctionsObjectPersonality | NSPointerFunctionsWeakMemory];
+  }
+
+  return self;
+}
+
+- (void)enumerateWithBlock:(RCTSurfaceEnumeratorBlock)block
+{
+  std::shared_lock lock(_mutex);
+  block([_registry objectEnumerator]);
+}
+
+- (void)registerSurface:(RCTFabricSurface *)surface
+{
+  std::unique_lock lock(_mutex);
+
+  ReactTag rootTag = surface.rootViewTag.integerValue;
+  [_registry setObject:surface forKey:(__bridge id)(void *)rootTag];
+}
+
+- (void)unregisterSurface:(RCTFabricSurface *)surface
+{
+  std::unique_lock lock(_mutex);
+
+  ReactTag rootTag = surface.rootViewTag.integerValue;
+  [_registry removeObjectForKey:(__bridge id)(void *)rootTag];
+}
+
+- (RCTFabricSurface *)surfaceForRootTag:(ReactTag)rootTag
+{
+  std::shared_lock lock(_mutex);
+
+  return [_registry objectForKey:(__bridge id)(void *)rootTag];
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfaceTouchHandler.h

@@ -0,0 +1,28 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTSurfaceTouchHandler : UIGestureRecognizer
+
+/*
+ * Attaches (and detaches) a view to the touch handler.
+ * The receiver does not retain the provided view.
+ */
+- (void)attachToView:(UIView *)view;
+- (void)detachFromView:(UIView *)view;
+
+/*
+ * Offset of the attached view relative to the root component in points.
+ */
+@property (nonatomic, assign) CGPoint viewOriginOffset;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTSurfaceTouchHandler.mm

@@ -0,0 +1,416 @@
+/*
+ * 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 "RCTSurfaceTouchHandler.h"
+
+#import <React/RCTIdentifierPool.h>
+#import <React/RCTUtils.h>
+#import <React/RCTViewComponentView.h>
+
+#import "RCTConversions.h"
+#import "RCTSurfacePointerHandler.h"
+#import "RCTTouchableComponentViewProtocol.h"
+
+using namespace facebook::react;
+
+typedef NS_ENUM(NSInteger, RCTTouchEventType) {
+  RCTTouchEventTypeTouchStart,
+  RCTTouchEventTypeTouchMove,
+  RCTTouchEventTypeTouchEnd,
+  RCTTouchEventTypeTouchCancel,
+};
+
+struct ActiveTouch {
+  Touch touch;
+  SharedTouchEventEmitter eventEmitter;
+
+  /*
+   * A component view on which the touch was begun.
+   */
+  __strong UIView<RCTComponentViewProtocol> *componentView = nil;
+
+  struct Hasher {
+    size_t operator()(const ActiveTouch &activeTouch) const
+    {
+      return std::hash<decltype(activeTouch.touch.identifier)>()(activeTouch.touch.identifier);
+    }
+  };
+
+  struct Comparator {
+    bool operator()(const ActiveTouch &lhs, const ActiveTouch &rhs) const
+    {
+      return lhs.touch.identifier == rhs.touch.identifier;
+    }
+  };
+};
+
+static void UpdateActiveTouchWithUITouch(
+    ActiveTouch &activeTouch,
+    UITouch *uiTouch,
+    UIView *rootComponentView,
+    CGPoint rootViewOriginOffset)
+{
+  CGPoint offsetPoint = [uiTouch locationInView:activeTouch.componentView];
+  CGPoint pagePoint = [uiTouch locationInView:rootComponentView];
+  CGPoint screenPoint = [rootComponentView convertPoint:pagePoint
+                                      toCoordinateSpace:rootComponentView.window.screen.coordinateSpace];
+  pagePoint = CGPointMake(pagePoint.x + rootViewOriginOffset.x, pagePoint.y + rootViewOriginOffset.y);
+
+  activeTouch.touch.offsetPoint = RCTPointFromCGPoint(offsetPoint);
+  activeTouch.touch.screenPoint = RCTPointFromCGPoint(screenPoint);
+  activeTouch.touch.pagePoint = RCTPointFromCGPoint(pagePoint);
+
+  activeTouch.touch.timestamp = uiTouch.timestamp;
+
+  if (RCTForceTouchAvailable()) {
+    activeTouch.touch.force = RCTZeroIfNaN(uiTouch.force / uiTouch.maximumPossibleForce);
+  }
+}
+
+static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponentView, CGPoint rootViewOriginOffset)
+{
+  ActiveTouch activeTouch = {};
+
+  // Find closest Fabric-managed touchable view
+  UIView *componentView = uiTouch.view;
+  while (componentView) {
+    if ([componentView respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
+      activeTouch.eventEmitter = [(id<RCTTouchableComponentViewProtocol>)componentView
+          touchEventEmitterAtPoint:[uiTouch locationInView:componentView]];
+      activeTouch.touch.target = (Tag)componentView.tag;
+      activeTouch.componentView = componentView;
+      break;
+    }
+    componentView = componentView.superview;
+  }
+
+  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset);
+  return activeTouch;
+}
+
+static BOOL AllTouchesAreCancelledOrEnded(NSSet<UITouch *> *touches)
+{
+  for (UITouch *touch in touches) {
+    if (touch.phase == UITouchPhaseBegan || touch.phase == UITouchPhaseMoved || touch.phase == UITouchPhaseStationary) {
+      return NO;
+    }
+  }
+  return YES;
+}
+
+static BOOL AnyTouchesChanged(NSSet<UITouch *> *touches)
+{
+  for (UITouch *touch in touches) {
+    if (touch.phase == UITouchPhaseBegan || touch.phase == UITouchPhaseMoved) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+/**
+ * Surprisingly, `__unsafe_unretained id` pointers are not regular pointers
+ * and `std::hash<>` cannot hash them.
+ * This is quite trivial but decent implementation of hasher function
+ * inspired by this research: https://stackoverflow.com/a/21062520/496389.
+ */
+template <typename PointerT>
+struct PointerHasher {
+  constexpr std::size_t operator()(const PointerT &value) const
+  {
+    return reinterpret_cast<size_t>(value);
+  }
+};
+
+@interface RCTSurfaceTouchHandler () <UIGestureRecognizerDelegate>
+@end
+
+@implementation RCTSurfaceTouchHandler {
+  std::unordered_map<__unsafe_unretained UITouch *, ActiveTouch, PointerHasher<__unsafe_unretained UITouch *>>
+      _activeTouches;
+
+  /*
+   * We hold the view weakly to prevent a retain cycle.
+   */
+  __weak UIView *_rootComponentView;
+  RCTIdentifierPool<11> _identifierPool;
+
+  RCTSurfacePointerHandler *_pointerHandler;
+}
+
+- (instancetype)init
+{
+  if (self = [super initWithTarget:nil action:nil]) {
+    // `cancelsTouchesInView` and `delaysTouches*` are needed in order
+    // to be used as a top level event delegated recognizer.
+    // Otherwise, lower-level components not built using React Native,
+    // will fail to recognize gestures.
+    self.cancelsTouchesInView = NO;
+    self.delaysTouchesBegan = NO; // This is default value.
+    self.delaysTouchesEnded = NO;
+
+    self.delegate = self;
+
+    if (RCTGetDispatchW3CPointerEvents()) {
+      _pointerHandler = [[RCTSurfacePointerHandler alloc] init];
+    }
+  }
+
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)action)
+
+- (void)attachToView:(UIView *)view
+{
+  RCTAssert(self.view == nil, @"RCTTouchHandler already has attached view.");
+
+  [view addGestureRecognizer:self];
+  _rootComponentView = view;
+
+  if (_pointerHandler != nil) {
+    [_pointerHandler attachToView:view];
+  }
+}
+
+- (void)detachFromView:(UIView *)view
+{
+  RCTAssertParam(view);
+  RCTAssert(self.view == view, @"RCTTouchHandler attached to another view.");
+
+  [view removeGestureRecognizer:self];
+  _rootComponentView = nil;
+
+  if (_pointerHandler != nil) {
+    [_pointerHandler detachFromView:view];
+  }
+}
+
+- (void)_registerTouches:(NSSet<UITouch *> *)touches
+{
+  for (UITouch *touch in touches) {
+    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset);
+    activeTouch.touch.identifier = _identifierPool.dequeue();
+    _activeTouches.emplace(touch, activeTouch);
+  }
+}
+
+- (void)_updateTouches:(NSSet<UITouch *> *)touches
+{
+  for (UITouch *touch in touches) {
+    auto iterator = _activeTouches.find(touch);
+    RCTAssert(iterator != _activeTouches.end(), @"Inconsistency between local and UIKit touch registries");
+    if (iterator == _activeTouches.end()) {
+      continue;
+    }
+
+    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset);
+  }
+}
+
+- (void)_unregisterTouches:(NSSet<UITouch *> *)touches
+{
+  for (UITouch *touch in touches) {
+    auto iterator = _activeTouches.find(touch);
+    RCTAssert(iterator != _activeTouches.end(), @"Inconsistency between local and UIKit touch registries");
+    if (iterator == _activeTouches.end()) {
+      continue;
+    }
+    auto &activeTouch = iterator->second;
+    _identifierPool.enqueue(activeTouch.touch.identifier);
+    _activeTouches.erase(touch);
+  }
+}
+
+- (std::vector<ActiveTouch>)_activeTouchesFromTouches:(NSSet<UITouch *> *)touches
+{
+  std::vector<ActiveTouch> activeTouches;
+  activeTouches.reserve(touches.count);
+
+  for (UITouch *touch in touches) {
+    auto iterator = _activeTouches.find(touch);
+    RCTAssert(iterator != _activeTouches.end(), @"Inconsistency between local and UIKit touch registries");
+    if (iterator == _activeTouches.end()) {
+      continue;
+    }
+    activeTouches.push_back(iterator->second);
+  }
+
+  return activeTouches;
+}
+
+- (void)_dispatchActiveTouches:(std::vector<ActiveTouch>)activeTouches eventType:(RCTTouchEventType)eventType
+{
+  TouchEvent event = {};
+  std::unordered_set<ActiveTouch, ActiveTouch::Hasher, ActiveTouch::Comparator> changedActiveTouches = {};
+  std::unordered_set<SharedTouchEventEmitter> uniqueEventEmitters = {};
+  BOOL isEndishEventType = eventType == RCTTouchEventTypeTouchEnd || eventType == RCTTouchEventTypeTouchCancel;
+
+  for (const auto &activeTouch : activeTouches) {
+    if (!activeTouch.eventEmitter) {
+      continue;
+    }
+
+    changedActiveTouches.insert(activeTouch);
+    event.changedTouches.insert(activeTouch.touch);
+    uniqueEventEmitters.insert(activeTouch.eventEmitter);
+  }
+
+  for (const auto &pair : _activeTouches) {
+    if (!pair.second.eventEmitter) {
+      continue;
+    }
+
+    if (isEndishEventType && event.changedTouches.find(pair.second.touch) != event.changedTouches.end()) {
+      continue;
+    }
+
+    event.touches.insert(pair.second.touch);
+  }
+
+  for (const auto &eventEmitter : uniqueEventEmitters) {
+    event.targetTouches.clear();
+
+    for (const auto &pair : _activeTouches) {
+      if (pair.second.eventEmitter == eventEmitter) {
+        event.targetTouches.insert(pair.second.touch);
+      }
+    }
+
+    switch (eventType) {
+      case RCTTouchEventTypeTouchStart:
+        eventEmitter->onTouchStart(event);
+        break;
+      case RCTTouchEventTypeTouchMove:
+        eventEmitter->onTouchMove(event);
+        break;
+      case RCTTouchEventTypeTouchEnd:
+        eventEmitter->onTouchEnd(event);
+        break;
+      case RCTTouchEventTypeTouchCancel:
+        eventEmitter->onTouchCancel(event);
+        break;
+    }
+  }
+}
+
+#pragma mark - `UIResponder`-ish touch-delivery methods
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+
+  [self _registerTouches:touches];
+  [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchStart];
+
+  if (self.state == UIGestureRecognizerStatePossible) {
+    self.state = UIGestureRecognizerStateBegan;
+  } else if (self.state == UIGestureRecognizerStateBegan) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+
+  [self _updateTouches:touches];
+  [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchMove];
+
+  self.state = UIGestureRecognizerStateChanged;
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+
+  [self _updateTouches:touches];
+  [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchEnd];
+  [self _unregisterTouches:touches];
+
+  if (AllTouchesAreCancelledOrEnded(event.allTouches)) {
+    self.state = UIGestureRecognizerStateEnded;
+  } else if (AnyTouchesChanged(event.allTouches)) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+
+  [self _updateTouches:touches];
+  [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchCancel];
+  [self _unregisterTouches:touches];
+
+  if (AllTouchesAreCancelledOrEnded(event.allTouches)) {
+    self.state = UIGestureRecognizerStateCancelled;
+  } else if (AnyTouchesChanged(event.allTouches)) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)reset
+{
+  [super reset];
+
+  if (!_activeTouches.empty()) {
+    std::vector<ActiveTouch> activeTouches;
+    activeTouches.reserve(_activeTouches.size());
+
+    for (const auto &pair : _activeTouches) {
+      activeTouches.push_back(pair.second);
+    }
+
+    [self _dispatchActiveTouches:activeTouches eventType:RCTTouchEventTypeTouchCancel];
+
+    // Force-unregistering all the touches.
+    _activeTouches.clear();
+    _identifierPool.reset();
+  }
+}
+
+- (BOOL)canPreventGestureRecognizer:(__unused UIGestureRecognizer *)preventedGestureRecognizer
+{
+  return NO;
+}
+
+- (BOOL)canBePreventedByGestureRecognizer:(UIGestureRecognizer *)preventingGestureRecognizer
+{
+  // We fail in favour of other external gesture recognizers.
+  // iOS will ask `delegate`'s opinion about this gesture recognizer little bit later.
+  return ![preventingGestureRecognizer.view isDescendantOfView:self.view];
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+- (BOOL)gestureRecognizer:(__unused UIGestureRecognizer *)gestureRecognizer
+    shouldRequireFailureOfGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  // Same condition for `failure of` as for `be prevented by`.
+  return [self canBePreventedByGestureRecognizer:otherGestureRecognizer];
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  BOOL canBePrevented = [self canBePreventedByGestureRecognizer:otherGestureRecognizer];
+  if (canBePrevented) {
+    [self _cancelTouches];
+  }
+  return NO;
+}
+
+#pragma mark -
+
+- (void)_cancelTouches
+{
+  [self setEnabled:NO];
+  [self setEnabled:YES];
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/RCTTouchableComponentViewProtocol.h

@@ -0,0 +1,13 @@
+/*
+ * 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/renderer/components/view/TouchEventEmitter.h>
+
+@protocol RCTTouchableComponentViewProtocol <NSObject>
+- (facebook::react::SharedTouchEventEmitter)touchEventEmitterAtPoint:(CGPoint)point;
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Surface/RCTFabricSurface.h

@@ -0,0 +1,132 @@
+/*
+ * 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 <React/RCTSurfaceProtocol.h>
+#import <react/renderer/scheduler/SurfaceHandler.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTBridge;
+@class RCTSurfaceView;
+@class RCTSurfacePresenter;
+
+/**
+ * (This is Fabric-compatible RCTSurface implementation.)
+ *
+ * RCTSurface instance represents React Native-powered piece of a user interface
+ * which can be a full-screen app, separate modal view controller,
+ * or even small widget.
+ * It is called "Surface".
+ *
+ * The RCTSurface instance is completely thread-safe by design;
+ * it can be created on any thread, and any its method can be called from
+ * any thread (if the opposite is not mentioned explicitly).
+ *
+ * The primary goals of the RCTSurface are:
+ *  * ability to measure and layout the surface in a thread-safe
+ *    and synchronous manner;
+ *  * ability to create a UIView instance on demand (later);
+ *  * ability to communicate the current stage of the surface granularly.
+ */
+@interface RCTFabricSurface : NSObject <RCTSurfaceProtocol>
+
+- (instancetype)initWithSurfacePresenter:(RCTSurfacePresenter *)surfacePresenter
+                              moduleName:(NSString *)moduleName
+                       initialProperties:(NSDictionary *)initialProperties;
+
+#pragma mark - Surface presenter
+
+/**
+ * EXPERIMENTAL
+ * Reset's the Surface to it's initial stage.
+ * It uses the passed in surface presenter, and whatever else was passed in init.
+ */
+- (void)resetWithSurfacePresenter:(RCTSurfacePresenter *)surfacePresenter;
+
+#pragma mark - Dealing with UIView representation, the Main thread only access
+
+/**
+ * Creates (if needed) and returns `UIView` instance which represents the Surface.
+ * The Surface will cache and *retain* this object.
+ * Returning the UIView instance does not mean that the Surface is ready
+ * to execute and layout. It can be just a handler which Surface will use later
+ * to mount the actual views.
+ * RCTSurface does not control (or influence in any way) the size or origin
+ * of this view. Some superview (or another owner) must use other methods
+ * of this class to setup proper layout and interop interactions with UIKit
+ * or another UI framework.
+ * This method must be called only from the main queue.
+ */
+- (RCTSurfaceView *)view;
+
+#pragma mark - Layout: Setting the size constrains
+
+/**
+ * Previously set `minimumSize` layout constraint.
+ * Defaults to `{0, 0}`.
+ */
+@property (atomic, assign, readonly) CGSize minimumSize;
+
+/**
+ * Previously set `maximumSize` layout constraint.
+ * Defaults to `{CGFLOAT_MAX, CGFLOAT_MAX}`.
+ */
+@property (atomic, assign, readonly) CGSize maximumSize;
+
+/**
+ * Previously set `viewportOffset` layout constraint.
+ * Defaults to `{0, 0}`.
+ */
+@property (atomic, assign, readonly) CGPoint viewportOffset;
+
+/**
+ * Simple shortcut to `-[RCTSurface setMinimumSize:size maximumSize:size]`.
+ */
+- (void)setSize:(CGSize)size;
+
+#pragma mark - Layout: Measuring
+
+/**
+ * Measures the Surface with given constraints.
+ * This method does not cause any side effects on the surface object.
+ */
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize;
+
+/**
+ * Return the current size of the root view based on (but not clamp by) current
+ * size constraints.
+ */
+@property (atomic, assign, readonly) CGSize intrinsicSize;
+
+#pragma mark - Synchronous waiting
+
+/**
+ * Synchronously blocks the current thread up to given `timeout` until
+ * the Surface is rendered.
+ */
+- (BOOL)synchronouslyWaitFor:(NSTimeInterval)timeout;
+
+@end
+
+@interface RCTFabricSurface (Internal)
+
+- (const facebook::react::SurfaceHandler &)surfaceHandler;
+
+@end
+
+@interface RCTFabricSurface (Deprecated)
+
+/**
+ * Deprecated. Use `initWithSurfacePresenter:moduleName:initialProperties` instead.
+ */
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Surface/RCTFabricSurface.mm

@@ -0,0 +1,303 @@
+/*
+ * 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 "RCTFabricSurface.h"
+
+#import <mutex>
+
+#import <React/RCTAssert.h>
+#import <React/RCTConstants.h>
+#import <React/RCTConversions.h>
+#import <React/RCTFollyConvert.h>
+#import <React/RCTI18nUtil.h>
+#import <React/RCTMountingManager.h>
+#import <React/RCTSurfaceDelegate.h>
+#import <React/RCTSurfaceRootView.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <React/RCTSurfaceView+Internal.h>
+#import <React/RCTSurfaceView.h>
+#import <React/RCTUIManagerUtils.h>
+#import <React/RCTUtils.h>
+#import <react/renderer/mounting/MountingCoordinator.h>
+
+#import "RCTSurfacePresenter.h"
+
+using namespace facebook::react;
+
+@implementation RCTFabricSurface {
+  __weak RCTSurfacePresenter *_surfacePresenter;
+
+  // `SurfaceHandler` is a thread-safe object, so we don't need additional synchronization.
+  // Objective-C++ classes cannot have instance variables without default constructors,
+  // hence we wrap a value into `optional` to workaround it.
+  std::optional<SurfaceHandler> _surfaceHandler;
+
+  // Protects Surface's start and stop processes.
+  // Even though SurfaceHandler is tread-safe, it will crash if we try to stop a surface that is not running.
+  // To make the API easy to use, we check the status of the surface before calling `start` or `stop`,
+  // and we need this mutex to prevent races.
+  std::mutex _surfaceMutex;
+
+  // Can be accessed from the main thread only.
+  RCTSurfaceView *_Nullable _view;
+  RCTSurfaceTouchHandler *_Nullable _touchHandler;
+}
+
+@synthesize delegate = _delegate;
+
+- (instancetype)initWithSurfacePresenter:(RCTSurfacePresenter *)surfacePresenter
+                              moduleName:(NSString *)moduleName
+                       initialProperties:(NSDictionary *)initialProperties
+{
+  if (self = [super init]) {
+    _surfacePresenter = surfacePresenter;
+
+    _surfaceHandler =
+        SurfaceHandler{RCTStringFromNSString(moduleName), (SurfaceId)[RCTAllocateRootViewTag() integerValue]};
+    _surfaceHandler->setProps(convertIdToFollyDynamic(initialProperties));
+
+    [_surfacePresenter registerSurface:self];
+
+    [self setMinimumSize:CGSizeZero maximumSize:RCTViewportSize()];
+
+    [self _updateLayoutContext];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(handleContentSizeCategoryDidChangeNotification:)
+                                                 name:UIContentSizeCategoryDidChangeNotification
+                                               object:nil];
+  }
+
+  return self;
+}
+
+- (void)resetWithSurfacePresenter:(RCTSurfacePresenter *)surfacePresenter
+{
+  _view = nil;
+  _surfacePresenter = surfacePresenter;
+  [_surfacePresenter registerSurface:self];
+}
+
+- (void)dealloc
+{
+  [_surfacePresenter unregisterSurface:self];
+}
+
+#pragma mark - Life-cycle management
+
+- (void)start
+{
+  std::lock_guard<std::mutex> lock(_surfaceMutex);
+
+  if (_surfaceHandler->getStatus() != SurfaceHandler::Status::Registered) {
+    return;
+  }
+
+  // We need to register a root view component here synchronously because right after
+  // we start a surface, it can initiate an update that can query the root component.
+  RCTUnsafeExecuteOnMainQueueSync(^{
+    [self->_surfacePresenter.mountingManager attachSurfaceToView:self.view
+                                                       surfaceId:self->_surfaceHandler->getSurfaceId()];
+  });
+
+  _surfaceHandler->start();
+  [self _propagateStageChange];
+
+  [_surfacePresenter setupAnimationDriverWithSurfaceHandler:*_surfaceHandler];
+}
+
+- (void)stop
+{
+  std::lock_guard<std::mutex> lock(_surfaceMutex);
+
+  if (_surfaceHandler->getStatus() != SurfaceHandler::Status::Running) {
+    return;
+  }
+
+  _surfaceHandler->stop();
+  [self _propagateStageChange];
+
+  RCTExecuteOnMainQueue(^{
+    [self->_surfacePresenter.mountingManager detachSurfaceFromView:self.view
+                                                         surfaceId:self->_surfaceHandler->getSurfaceId()];
+  });
+}
+
+#pragma mark - Immutable Properties (no need to enforce synchronization)
+
+- (NSString *)moduleName
+{
+  return RCTNSStringFromString(_surfaceHandler->getModuleName());
+}
+
+#pragma mark - Main-Threaded Routines
+
+- (RCTSurfaceView *)view
+{
+  RCTAssertMainQueue();
+
+  if (!_view) {
+    _view = [[RCTSurfaceView alloc] initWithSurface:(RCTSurface *)self];
+    _touchHandler = [RCTSurfaceTouchHandler new];
+    [_touchHandler attachToView:_view];
+  }
+
+  return _view;
+}
+
+#pragma mark - Stage management
+
+- (RCTSurfaceStage)stage
+{
+  return _surfaceHandler->getStatus() == SurfaceHandler::Status::Running ? RCTSurfaceStageRunning
+                                                                         : RCTSurfaceStagePreparing;
+}
+
+- (void)_propagateStageChange
+{
+  RCTSurfaceStage stage = self.stage;
+
+  // Notifying the `delegate`
+  id<RCTSurfaceDelegate> delegate = self.delegate;
+  if ([delegate respondsToSelector:@selector(surface:didChangeStage:)]) {
+    [delegate surface:(RCTSurface *)self didChangeStage:stage];
+  }
+}
+
+- (void)_updateLayoutContext
+{
+  auto layoutConstraints = _surfaceHandler->getLayoutConstraints();
+  layoutConstraints.layoutDirection = RCTLayoutDirection([[RCTI18nUtil sharedInstance] isRTL]);
+
+  auto layoutContext = _surfaceHandler->getLayoutContext();
+
+  layoutContext.pointScaleFactor = RCTScreenScale();
+  layoutContext.swapLeftAndRightInRTL =
+      [[RCTI18nUtil sharedInstance] isRTL] && [[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL];
+  layoutContext.fontSizeMultiplier = RCTFontSizeMultiplier();
+
+  _surfaceHandler->constraintLayout(layoutConstraints, layoutContext);
+}
+
+#pragma mark - Properties Management
+
+- (NSDictionary *)properties
+{
+  return convertFollyDynamicToId(_surfaceHandler->getProps());
+}
+
+- (void)setProperties:(NSDictionary *)properties
+{
+  _surfaceHandler->setProps(convertIdToFollyDynamic(properties));
+}
+
+#pragma mark - Layout
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize viewportOffset:(CGPoint)viewportOffset
+{
+  auto layoutConstraints = _surfaceHandler->getLayoutConstraints();
+  auto layoutContext = _surfaceHandler->getLayoutContext();
+
+  layoutConstraints.minimumSize = RCTSizeFromCGSize(minimumSize);
+  layoutConstraints.maximumSize = RCTSizeFromCGSize(maximumSize);
+
+  if (!isnan(viewportOffset.x) && !isnan(viewportOffset.y)) {
+    layoutContext.viewportOffset = RCTPointFromCGPoint(viewportOffset);
+  }
+
+  _surfaceHandler->constraintLayout(layoutConstraints, layoutContext);
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+  [self setMinimumSize:minimumSize maximumSize:maximumSize viewportOffset:CGPointMake(NAN, NAN)];
+}
+
+- (void)setSize:(CGSize)size
+{
+  [self setMinimumSize:size maximumSize:size];
+}
+
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+  auto layoutConstraints = _surfaceHandler->getLayoutConstraints();
+  auto layoutContext = _surfaceHandler->getLayoutContext();
+
+  layoutConstraints.minimumSize = RCTSizeFromCGSize(minimumSize);
+  layoutConstraints.maximumSize = RCTSizeFromCGSize(maximumSize);
+
+  return RCTCGSizeFromSize(_surfaceHandler->measure(layoutConstraints, layoutContext));
+}
+
+- (CGSize)minimumSize
+{
+  return RCTCGSizeFromSize(_surfaceHandler->getLayoutConstraints().minimumSize);
+}
+
+- (CGSize)maximumSize
+{
+  return RCTCGSizeFromSize(_surfaceHandler->getLayoutConstraints().maximumSize);
+}
+
+- (CGPoint)viewportOffset
+{
+  return RCTCGPointFromPoint(_surfaceHandler->getLayoutContext().viewportOffset);
+}
+
+#pragma mark - Synchronous Waiting
+
+- (BOOL)synchronouslyWaitFor:(NSTimeInterval)timeout
+{
+  auto mountingCoordinator = _surfaceHandler->getMountingCoordinator();
+
+  if (!mountingCoordinator) {
+    return NO;
+  }
+
+  if (!mountingCoordinator->waitForTransaction(std::chrono::duration<NSTimeInterval>(timeout))) {
+    return NO;
+  }
+
+  [_surfacePresenter.mountingManager scheduleTransaction:mountingCoordinator];
+
+  return YES;
+}
+
+- (void)handleContentSizeCategoryDidChangeNotification:(NSNotification *)notification
+{
+  [self _updateLayoutContext];
+}
+
+#pragma mark - Private
+
+- (const SurfaceHandler &)surfaceHandler;
+{
+  return *_surfaceHandler;
+}
+
+#pragma mark - Deprecated
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties
+{
+  return [self initWithSurfacePresenter:bridge.surfacePresenter
+                             moduleName:moduleName
+                      initialProperties:initialProperties];
+}
+
+- (NSNumber *)rootViewTag
+{
+  return @(_surfaceHandler->getSurfaceId());
+}
+
+- (NSInteger)rootTag
+{
+  return (NSInteger)(_surfaceHandler->getSurfaceId());
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/PlatformRunLoopObserver.h

@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <CoreFoundation/CFRunLoop.h>
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <react/utils/RunLoopObserver.h>
+
+namespace facebook::react {
+
+/*
+ * Concrete iOS-specific implementation of `RunLoopObserver` using
+ * `CFRunLoopObserver` under the hood.
+ */
+class PlatformRunLoopObserver : public RunLoopObserver {
+ public:
+  PlatformRunLoopObserver(
+      RunLoopObserver::Activity activities,
+      const RunLoopObserver::WeakOwner& owner,
+      CFRunLoopRef runLoop);
+
+  ~PlatformRunLoopObserver();
+
+  virtual bool isOnRunLoopThread() const noexcept override;
+
+ private:
+  void startObserving() const noexcept override;
+  void stopObserving() const noexcept override;
+
+  CFRunLoopRef runLoop_;
+  CFRunLoopObserverRef mainRunLoopObserver_;
+};
+
+/*
+ * Convenience specialization of `PlatformRunLoopObserver` observing the main
+ * run loop.
+ */
+class MainRunLoopObserver final : public PlatformRunLoopObserver {
+ public:
+  MainRunLoopObserver(
+      RunLoopObserver::Activity activities,
+      const RunLoopObserver::WeakOwner& owner)
+      : PlatformRunLoopObserver(activities, owner, CFRunLoopGetMain()) {}
+};
+
+} // namespace facebook::react

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/PlatformRunLoopObserver.mm

@@ -0,0 +1,95 @@
+/*
+ * 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 "PlatformRunLoopObserver.h"
+
+#import <mutex>
+
+namespace facebook::react {
+
+static CFRunLoopActivity toCFRunLoopActivity(RunLoopObserver::Activity activity)
+{
+  auto result = CFRunLoopActivity{};
+
+  if (RunLoopObserver::Activity(activity & RunLoopObserver::Activity::BeforeWaiting) ==
+      RunLoopObserver::Activity::BeforeWaiting) {
+    result = result | kCFRunLoopBeforeWaiting;
+  }
+
+  if (RunLoopObserver::Activity(activity & RunLoopObserver::Activity::AfterWaiting) ==
+      RunLoopObserver::Activity::AfterWaiting) {
+    result = result | kCFRunLoopAfterWaiting;
+  }
+
+  return result;
+}
+
+static RunLoopObserver::Activity toRunLoopActivity(CFRunLoopActivity activity)
+{
+  auto result = RunLoopObserver::Activity{};
+
+  if (CFRunLoopActivity(activity & kCFRunLoopBeforeWaiting) == kCFRunLoopBeforeWaiting) {
+    result = RunLoopObserver::Activity(result | RunLoopObserver::Activity::BeforeWaiting);
+  }
+
+  if (CFRunLoopActivity(activity & kCFRunLoopAfterWaiting) == kCFRunLoopAfterWaiting) {
+    result = RunLoopObserver::Activity(result | RunLoopObserver::Activity::AfterWaiting);
+  }
+
+  return result;
+}
+
+PlatformRunLoopObserver::PlatformRunLoopObserver(
+    RunLoopObserver::Activity activities,
+    const RunLoopObserver::WeakOwner &owner,
+    CFRunLoopRef runLoop)
+    : RunLoopObserver(activities, owner), runLoop_(runLoop)
+{
+  // A value (not a reference) to be captured by the block.
+  auto weakOwner = owner;
+
+  // The documentation for `CFRunLoop` family API states that all of the methods are thread-safe.
+  // See "Thread Safety and Run Loop Objects" section of the "Threading Programming Guide" for more details.
+  mainRunLoopObserver_ = CFRunLoopObserverCreateWithHandler(
+      NULL /* allocator */,
+      toCFRunLoopActivity(activities_) /* activities */,
+      true /* repeats */,
+      0 /* order */,
+      ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
+        auto strongOwner = weakOwner.lock();
+        if (!strongOwner) {
+          return;
+        }
+
+        this->activityDidChange(toRunLoopActivity(activity));
+      });
+
+  assert(mainRunLoopObserver_);
+}
+
+PlatformRunLoopObserver::~PlatformRunLoopObserver()
+{
+  stopObserving();
+  CFRelease(mainRunLoopObserver_);
+}
+
+void PlatformRunLoopObserver::startObserving() const noexcept
+{
+  CFRunLoopAddObserver(runLoop_, mainRunLoopObserver_, kCFRunLoopCommonModes);
+}
+
+void PlatformRunLoopObserver::stopObserving() const noexcept
+{
+  CFRunLoopRemoveObserver(runLoop_, mainRunLoopObserver_, kCFRunLoopCommonModes);
+}
+
+bool PlatformRunLoopObserver::isOnRunLoopThread() const noexcept
+{
+  return CFRunLoopGetCurrent() == runLoop_;
+}
+
+} // namespace facebook::react

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/RCTGenericDelegateSplitter.h

@@ -0,0 +1,44 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * General purpose implementation of Delegate Splitter (or Multicast) pattern which allows subscribing multiple
+ * `receiving` objects to single `sending` object (which normally does not support that feature by itself).
+ *
+ * In the case where only one receiving object is registered, using Splitter has zero performance overhead because the
+ * receiver is being subscribed directly. In the case where more than one receiving objects are registered, using
+ * Splitter introduces some performance overhead.
+ */
+@interface RCTGenericDelegateSplitter<DelegateT> : NSObject
+
+@property (nonatomic, copy, nullable) void (^delegateUpdateBlock)(DelegateT _Nullable delegate);
+
+/*
+ * Creates an object with a given block that will be used to connect a `sending` object with a given `receiving` object.
+ * The class calls the block every time after each delegate adding or removing procedure, and it calls it twice: the
+ * first time with `nil` and the second time with actual delegate. This is required to establish a proper connection
+ * between sending and receiving objects (to reset caches storing information about supported (or not) optional
+ * methods).
+ */
+- (instancetype)initWithDelegateUpdateBlock:(void (^)(DelegateT _Nullable delegate))block;
+
+/*
+ * Adds and removes a delegate.
+ * The delegates will be called in order of registration.
+ * If a delegate returns a value, the value from the last call will be passed to the `sending` object.
+ */
+- (void)addDelegate:(DelegateT)delegate;
+- (void)removeDelegate:(DelegateT)delegate;
+- (void)removeAllDelegates;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/RCTGenericDelegateSplitter.mm

@@ -0,0 +1,94 @@
+/*
+ * 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 "RCTGenericDelegateSplitter.h"
+
+@implementation RCTGenericDelegateSplitter {
+  NSHashTable *_delegates;
+}
+
+#pragma mark - Public
+
+- (instancetype)initWithDelegateUpdateBlock:(void (^)(id _Nullable delegate))block
+{
+  if (self = [super init]) {
+    _delegateUpdateBlock = block;
+    _delegates = [NSHashTable weakObjectsHashTable];
+  }
+
+  return self;
+}
+
+- (void)addDelegate:(id)delegate
+{
+  [_delegates addObject:delegate];
+  [self _updateDelegate];
+}
+
+- (void)removeDelegate:(id)delegate
+{
+  [_delegates removeObject:delegate];
+  [self _updateDelegate];
+}
+
+- (void)removeAllDelegates
+{
+  [_delegates removeAllObjects];
+  [self _updateDelegate];
+}
+
+#pragma mark - Private
+
+- (void)_updateDelegate
+{
+  _delegateUpdateBlock(nil);
+  if (_delegates.count == 0) {
+    return;
+  }
+
+  _delegateUpdateBlock(_delegates.count == 1 ? [_delegates allObjects].firstObject : self);
+}
+
+#pragma mark - Fast Forwarding
+
+- (BOOL)respondsToSelector:(SEL)selector
+{
+  for (id delegate in _delegates) {
+    if ([delegate respondsToSelector:selector]) {
+      return YES;
+    }
+  }
+
+  return NO;
+}
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
+{
+  for (id delegate in _delegates) {
+    if ([delegate respondsToSelector:selector]) {
+      return [delegate methodSignatureForSelector:selector];
+    }
+  }
+  return nil;
+}
+
+- (void)forwardInvocation:(NSInvocation *)invocation
+{
+  NSMutableArray *targets = [[NSMutableArray alloc] initWithCapacity:_delegates.count];
+
+  for (id delegate in _delegates) {
+    if ([delegate respondsToSelector:[invocation selector]]) {
+      [targets addObject:delegate];
+    }
+  }
+
+  for (id target in targets) {
+    [invocation invokeWithTarget:target];
+  }
+}
+
+@end

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/RCTIdentifierPool.h

@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <bitset>
+
+namespace facebook::react {
+
+template <size_t size>
+class RCTIdentifierPool {
+ public:
+  void enqueue(int index) {
+    usage[index] = false;
+  }
+
+  int dequeue() {
+    while (true) {
+      if (!usage[lastIndex]) {
+        usage[lastIndex] = true;
+        return lastIndex;
+      }
+      lastIndex = (lastIndex + 1) % size;
+    }
+  }
+
+  void reset() {
+    for (int i = 0; i < size; i++) {
+      usage[i] = false;
+    }
+  }
+
+ private:
+  std::bitset<size> usage;
+  int lastIndex;
+};
+
+} // namespace facebook::react

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/RCTReactTaggedView.h

@@ -0,0 +1,34 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Lightweight wrapper class around a UIView with a react tag which registers a
+ * constant react tag at initialization time for a stable hash and provides the
+ * udnerlying view to a caller if that underlying view's react tag has not
+ * changed from the one provided at initialization time (i.e. recycled).
+ */
+@interface RCTReactTaggedView : NSObject {
+  UIView *_view;
+  NSInteger _tag;
+}
+
++ (RCTReactTaggedView *)wrap:(UIView *)view;
+
+- (instancetype)initWithView:(UIView *)view;
+- (nullable UIView *)view;
+- (NSInteger)tag;
+
+- (BOOL)isEqual:(id)other;
+- (NSUInteger)hash;
+
+@end
+
+NS_ASSUME_NONNULL_END

smart-app-city/frontend/node_modules/react-native/React/Fabric/Utils/RCTReactTaggedView.mm

@@ -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 "RCTReactTaggedView.h"
+
+@implementation RCTReactTaggedView
+
++ (RCTReactTaggedView *)wrap:(UIView *)view
+{
+  return [[RCTReactTaggedView alloc] initWithView:view];
+}
+
+- (instancetype)initWithView:(UIView *)view
+{
+  if (self = [super init]) {
+    _view = view;
+    _tag = view.tag;
+  }
+  return self;
+}
+
+- (nullable UIView *)view
+{
+  if (_view.tag == _tag) {
+    return _view;
+  }
+  return nil;
+}
+
+- (NSInteger)tag
+{
+  return _tag;
+}
+
+- (BOOL)isEqual:(id)other
+{
+  if (other == self) {
+    return YES;
+  }
+  if (!other || ![other isKindOfClass:[self class]]) {
+    return NO;
+  }
+  return _tag == [other tag];
+}
+
+- (NSUInteger)hash
+{
+  return _tag;
+}
+
+@end