first commit

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 frameInContainerSpace;
+@end
+
+NS_ASSUME_NONNULL_END

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(_frameInContainerSpace, CGRectZero)) {
+    return UIAccessibilityConvertFrameToScreenCoordinates(container.bounds, container);
+  } else {
+    return UIAccessibilityConvertFrameToScreenCoordinates(_frameInContainerSpace, container);
+  }
+}
+
+@end

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

node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentAccessibilityProvider.mm

@@ -0,0 +1,186 @@
+/*
+ * 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];
+  firstElement.isAccessibilityElement = YES;
+  firstElement.accessibilityTraits = _view.accessibilityTraits;
+  firstElement.accessibilityLabel = accessibilityLabel;
+  firstElement.accessibilityLanguage = _view.accessibilityLanguage;
+  [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 ((![value isEqualToString:@"button"] && ![value isEqualToString:@"link"])) {
+                                       return;
+                                     }
+
+                                     if ([fragmentText isEqualToString:firstElement.accessibilityLabel]) {
+                                       if ([value isEqualToString:@"link"]) {
+                                         firstElement.accessibilityTraits |= UIAccessibilityTraitLink;
+                                       } else if ([value isEqualToString:@"button"]) {
+                                         firstElement.accessibilityTraits |= UIAccessibilityTraitButton;
+                                       }
+                                       // The fragment is the entire paragraph. This is handled as `firstElement`.
+                                       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.frameInContainerSpace = 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

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

node_modules/react-native/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentView.mm

@@ -0,0 +1,413 @@
+/*
+ * 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;
+
+// ParagraphTextView is an auxiliary view we set as contentView so the drawing
+// can happen on top of the layers manipulated by RCTViewComponentView (the parent view)
+@interface RCTParagraphTextView : UIView
+
+@property (nonatomic) ParagraphShadowNode::ConcreteState::Shared state;
+@property (nonatomic) ParagraphAttributes paragraphAttributes;
+@property (nonatomic) LayoutMetrics layoutMetrics;
+
+@end
+
+@interface RCTParagraphComponentView () <UIEditMenuInteractionDelegate>
+
+@property (nonatomic, nullable) UIEditMenuInteraction *editMenuInteraction API_AVAILABLE(ios(16.0));
+
+@end
+
+@implementation RCTParagraphComponentView {
+  ParagraphAttributes _paragraphAttributes;
+  RCTParagraphComponentAccessibilityProvider *_accessibilityProvider;
+  UILongPressGestureRecognizer *_longPressGestureRecognizer;
+  RCTParagraphTextView *_textView;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = ParagraphShadowNode::defaultSharedProps();
+
+    self.opaque = NO;
+    _textView = [RCTParagraphTextView new];
+    _textView.backgroundColor = UIColor.clearColor;
+    self.contentView = _textView;
+  }
+
+  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 (!_textView.state) {
+    return nil;
+  }
+
+  return RCTNSAttributedStringFromAttributedString(_textView.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;
+  _textView.paragraphAttributes = _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
+{
+  _textView.state = std::static_pointer_cast<const ParagraphShadowNode::ConcreteState>(state);
+  [_textView setNeedsDisplay];
+  [self setNeedsLayout];
+}
+
+- (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];
+  _textView.layoutMetrics = _layoutMetrics;
+  [_textView setNeedsDisplay];
+  [self setNeedsLayout];
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _textView.state = nullptr;
+  _accessibilityProvider = nil;
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+
+  _textView.frame = self.bounds;
+}
+
+#pragma mark - Accessibility
+
+- (NSString *)accessibilityLabel
+{
+  NSString *label = super.accessibilityLabel;
+  if ([label length] > 0) {
+    return label;
+  }
+  return self.attributedText.string;
+}
+
+- (NSString *)accessibilityLabelForCoopting
+{
+  return self.accessibilityLabel;
+}
+
+- (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 (!_textView.state || !paragraphProps.accessible) {
+    return [NSArray new];
+  }
+
+  auto &data = _textView.state->getData();
+
+  if (![_accessibilityProvider isUpToDate:data.attributedString]) {
+    auto textLayoutManager = data.layoutManager.lock();
+    if (textLayoutManager) {
+      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];
+    }
+  }
+
+  NSArray<UIAccessibilityElement *> *elements = _accessibilityProvider.accessibilityElements;
+  if ([elements count] > 0) {
+    elements[0].isAccessibilityElement =
+        elements[0].accessibilityTraits & UIAccessibilityTraitLink || ![self isAccessibilityCoopted];
+  }
+  return elements;
+}
+
+- (BOOL)isAccessibilityCoopted
+{
+  UIView *ancestor = self.superview;
+  NSMutableSet<UIView *> *cooptingCandidates = [NSMutableSet new];
+  while (ancestor) {
+    if ([ancestor isKindOfClass:[RCTViewComponentView class]]) {
+      if ([((RCTViewComponentView *)ancestor) accessibilityLabelForCoopting]) {
+        // We found a label above us. That would be coopted before we would be
+        return NO;
+      } else if ([((RCTViewComponentView *)ancestor) wantsToCooptLabel]) {
+        // We found an view that is looking to coopt a label below it
+        [cooptingCandidates addObject:ancestor];
+      }
+
+      NSArray *elements = ancestor.accessibilityElements;
+      if ([elements count] > 0 && [cooptingCandidates count] > 0) {
+        for (NSObject *element in elements) {
+          if ([element isKindOfClass:[UIView class]] && [cooptingCandidates containsObject:((UIView *)element)]) {
+            return YES;
+          }
+        }
+      }
+    } else if (![ancestor isKindOfClass:[RCTViewComponentView class]] && ancestor.accessibilityLabel) {
+      // Same as above, for UIView case. Cannot call this on RCTViewComponentView
+      // as it is recursive and quite expensive.
+      return NO;
+    }
+    ancestor = ancestor.superview;
+  }
+
+  return NO;
+}
+
+- (UIAccessibilityTraits)accessibilityTraits
+{
+  return [super accessibilityTraits] | UIAccessibilityTraitStaticText;
+}
+
+#pragma mark - RCTTouchableComponentViewProtocol
+
+- (SharedTouchEventEmitter)touchEventEmitterAtPoint:(CGPoint)point
+{
+  const auto &state = _textView.state;
+  if (!state) {
+    return _eventEmitter;
+  }
+
+  const auto &stateData = state->getData();
+  auto textLayoutManager = stateData.layoutManager.lock();
+
+  if (!textLayoutManager) {
+    return _eventEmitter;
+  }
+
+  RCTTextLayoutManager *nativeTextLayoutManager =
+      (RCTTextLayoutManager *)unwrapManagedObject(textLayoutManager->getNativeTextLayoutManager());
+  CGRect frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+
+  auto eventEmitter = [nativeTextLayoutManager getEventEmitterWithAttributeString:stateData.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;
+}
+
+@implementation RCTParagraphTextView {
+  CAShapeLayer *_highlightLayer;
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  return nil;
+}
+
+- (void)drawRect:(CGRect)rect
+{
+  if (!_state) {
+    return;
+  }
+
+  const auto &stateData = _state->getData();
+  auto textLayoutManager = stateData.layoutManager.lock();
+  if (!textLayoutManager) {
+    return;
+  }
+
+  RCTTextLayoutManager *nativeTextLayoutManager =
+      (RCTTextLayoutManager *)unwrapManagedObject(textLayoutManager->getNativeTextLayoutManager());
+
+  CGRect frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
+
+  [nativeTextLayoutManager drawAttributedString:stateData.attributedString
+                            paragraphAttributes:_paragraphAttributes
+                                          frame:frame
+                              drawHighlightPath:^(UIBezierPath *highlightPath) {
+                                if (highlightPath) {
+                                  if (!self->_highlightLayer) {
+                                    self->_highlightLayer = [CAShapeLayer layer];
+                                    self->_highlightLayer.fillColor = [UIColor colorWithWhite:0 alpha:0.25].CGColor;
+                                    [self.layer addSublayer:self->_highlightLayer];
+                                  }
+                                  self->_highlightLayer.position = frame.origin;
+                                  self->_highlightLayer.path = highlightPath.CGPath;
+                                } else {
+                                  [self->_highlightLayer removeFromSuperlayer];
+                                  self->_highlightLayer = nil;
+                                }
+                              }];
+}
+
+@end