react-native-enriched 0.4.1 → 0.5.0

package/ios/EnrichedTextInputView.mm

@@ -50,6 +50,7 @@ using namespace facebook::react;
   BOOL _emitFocusBlur;
   BOOL _emitTextChange;
   NSMutableDictionary<NSValue *, UIImageView *> *_attachmentViews;
+  NSArray<NSDictionary *> *_contextMenuItems;
 }
 
 // MARK: - Component utils
@@ -332,6 +333,11 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
     stylePropChanged = YES;
   }
 
+  if (newViewProps.lineHeight != oldViewProps.lineHeight) {
+    [newConfig setPrimaryLineHeight:newViewProps.lineHeight];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.fontWeight != oldViewProps.fontWeight) {
     if (!newViewProps.fontWeight.empty()) {
       [newConfig
@@ -731,11 +737,16 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
         [config primaryColor];
     defaultTypingAttributes[NSStrikethroughColorAttributeName] =
         [config primaryColor];
-    defaultTypingAttributes[NSParagraphStyleAttributeName] =
-        [[NSParagraphStyle alloc] init];
+    NSMutableParagraphStyle *defaultPStyle =
+        [[NSMutableParagraphStyle alloc] init];
+    defaultPStyle.minimumLineHeight = [config scaledPrimaryLineHeight];
+    defaultTypingAttributes[NSParagraphStyleAttributeName] = defaultPStyle;
+
     textView.typingAttributes = defaultTypingAttributes;
     textView.selectedRange = prevSelectedRange;
 
+    // make sure the newest lineHeight is applied
+    [self refreshLineHeight];
     // update the placeholder as well
     [self refreshPlaceholderLabelStyles];
   }
@@ -745,6 +756,11 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
     textView.editable = newViewProps.editable;
   }
 
+  // useHtmlNormalizer
+  if (newViewProps.useHtmlNormalizer != oldViewProps.useHtmlNormalizer) {
+    useHtmlNormalizer = newViewProps.useHtmlNormalizer;
+  }
+
   // default value - must be set before placeholder to make sure it correctly
   // shows on first mount
   if (newViewProps.defaultValue != oldViewProps.defaultValue) {
@@ -850,6 +866,26 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
   // isOnChangeTextSet
   _emitTextChange = newViewProps.isOnChangeTextSet;
 
+  // contextMenuItems
+  bool contextMenuChanged = newViewProps.contextMenuItems.size() !=
+                            oldViewProps.contextMenuItems.size();
+  if (!contextMenuChanged) {
+    for (size_t i = 0; i < newViewProps.contextMenuItems.size(); i++) {
+      if (newViewProps.contextMenuItems[i].text !=
+          oldViewProps.contextMenuItems[i].text) {
+        contextMenuChanged = true;
+        break;
+      }
+    }
+  }
+  if (contextMenuChanged) {
+    NSMutableArray<NSString *> *items = [NSMutableArray new];
+    for (const auto &item : newViewProps.contextMenuItems) {
+      [items addObject:[NSString fromCppString:item.text]];
+    }
+    _contextMenuItems = [items copy];
+  }
+
   [super updateProps:props oldProps:oldProps];
   // run the changes callback
   [self anyTextMayHaveBeenModified];
@@ -880,6 +916,24 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
   _placeholderLabel.attributedText = newAttrStr;
 }
 
+- (void)refreshLineHeight {
+  [textView.textStorage
+      enumerateAttribute:NSParagraphStyleAttributeName
+                 inRange:NSMakeRange(0, textView.textStorage.string.length)
+                 options:0
+              usingBlock:^(id _Nullable value, NSRange range,
+                           BOOL *_Nonnull stop) {
+                NSMutableParagraphStyle *pStyle =
+                    [(NSParagraphStyle *)value mutableCopy];
+                if (pStyle == nil)
+                  return;
+                pStyle.minimumLineHeight = [config scaledPrimaryLineHeight];
+                [textView.textStorage addAttribute:NSParagraphStyleAttributeName
+                                             value:pStyle
+                                             range:range];
+              }];
+}
+
 // MARK: - Measuring and states
 
 - (CGSize)measureSize:(CGFloat)maxWidth {
@@ -1180,6 +1234,10 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
     NSString *text = (NSString *)args[2];
     NSString *url = (NSString *)args[3];
     [self addLinkAt:start end:end text:text url:url];
+  } else if ([commandName isEqualToString:@"removeLink"]) {
+    NSInteger start = [((NSNumber *)args[0]) integerValue];
+    NSInteger end = [((NSNumber *)args[1]) integerValue];
+    [self removeLinkAt:start end:end];
   } else if ([commandName isEqualToString:@"addMention"]) {
     NSString *indicator = (NSString *)args[0];
     NSString *text = (NSString *)args[1];
@@ -1468,6 +1526,29 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
   }
 }
 
+- (void)removeLinkAt:(NSInteger)start end:(NSInteger)end {
+  LinkStyle *linkStyleClass =
+      (LinkStyle *)stylesDict[@([LinkStyle getStyleType])];
+  if (linkStyleClass == nullptr) {
+    return;
+  }
+
+  NSInteger textLength = (NSInteger)textView.textStorage.length;
+  if (start < 0) {
+    start = 0;
+  }
+  if (end > textLength) {
+    end = textLength;
+  }
+
+  NSInteger rangeStart = MIN(start, end);
+  NSInteger rangeLength = MAX(start, end) - rangeStart;
+  NSRange linkRange = NSMakeRange(rangeStart, rangeLength);
+
+  [linkStyleClass removeAttributes:linkRange];
+  [self anyTextMayHaveBeenModified];
+}
+
 - (void)addMention:(NSString *)indicator
               text:(NSString *)text
         attributes:(NSString *)attributes {
@@ -1798,6 +1879,75 @@ Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
   }
 }
 
+- (UIMenu *)textView:(UITextView *)tv
+    editMenuForTextInRange:(NSRange)range
+          suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions
+    API_AVAILABLE(ios(16.0)) {
+  if (_contextMenuItems == nil || _contextMenuItems.count == 0) {
+    return [UIMenu menuWithChildren:suggestedActions];
+  }
+
+  NSMutableArray<UIMenuElement *> *customActions = [NSMutableArray new];
+
+  for (NSString *title in _contextMenuItems) {
+    __weak EnrichedTextInputView *weakSelf = self;
+
+    UIAction *action =
+        [UIAction actionWithTitle:title
+                            image:nil
+                       identifier:nil
+                          handler:^(__kindof UIAction *_Nonnull action) {
+                            [weakSelf emitOnContextMenuItemPressEvent:title];
+                          }];
+    [customActions addObject:action];
+  }
+
+  [customActions addObjectsFromArray:suggestedActions];
+  return [UIMenu menuWithChildren:customActions];
+}
+
+- (void)emitOnContextMenuItemPressEvent:(NSString *)itemText {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    NSRange selectedRange = textView.selectedRange;
+    NSString *selectedText = @"";
+    if (selectedRange.length > 0) {
+      selectedText =
+          [textView.textStorage.string substringWithRange:selectedRange];
+    }
+
+    emitter->onContextMenuItemPress(
+        {.itemText = [itemText toCppString],
+         .selectedText = [selectedText toCppString],
+         .selectionStart = static_cast<int>(selectedRange.location),
+         .selectionEnd =
+             static_cast<int>(selectedRange.location + selectedRange.length),
+         .styleState = {
+             .bold = GET_STYLE_STATE([BoldStyle getStyleType]),
+             .italic = GET_STYLE_STATE([ItalicStyle getStyleType]),
+             .underline = GET_STYLE_STATE([UnderlineStyle getStyleType]),
+             .strikeThrough =
+                 GET_STYLE_STATE([StrikethroughStyle getStyleType]),
+             .inlineCode = GET_STYLE_STATE([InlineCodeStyle getStyleType]),
+             .h1 = GET_STYLE_STATE([H1Style getStyleType]),
+             .h2 = GET_STYLE_STATE([H2Style getStyleType]),
+             .h3 = GET_STYLE_STATE([H3Style getStyleType]),
+             .h4 = GET_STYLE_STATE([H4Style getStyleType]),
+             .h5 = GET_STYLE_STATE([H5Style getStyleType]),
+             .h6 = GET_STYLE_STATE([H6Style getStyleType]),
+             .codeBlock = GET_STYLE_STATE([CodeBlockStyle getStyleType]),
+             .blockQuote = GET_STYLE_STATE([BlockQuoteStyle getStyleType]),
+             .orderedList = GET_STYLE_STATE([OrderedListStyle getStyleType]),
+             .unorderedList =
+                 GET_STYLE_STATE([UnorderedListStyle getStyleType]),
+             .link = GET_STYLE_STATE([LinkStyle getStyleType]),
+             .image = GET_STYLE_STATE([ImageStyle getStyleType]),
+             .mention = GET_STYLE_STATE([MentionStyle getStyleType]),
+             .checkboxList =
+                 GET_STYLE_STATE([CheckboxListStyle getStyleType])}});
+  }
+}
+
 - (void)handleKeyPressInRange:(NSString *)text range:(NSRange)range {
   NSString *key = nil;
 

package/ios/config/InputConfig.h

@@ -10,6 +10,9 @@
 - (void)setPrimaryColor:(UIColor *)newValue;
 - (NSNumber *)primaryFontSize;
 - (void)setPrimaryFontSize:(NSNumber *)newValue;
+- (CGFloat)primaryLineHeight;
+- (void)setPrimaryLineHeight:(CGFloat)newValue;
+- (CGFloat)scaledPrimaryLineHeight;
 - (NSString *)primaryFontWeight;
 - (void)setPrimaryFontWeight:(NSString *)newValue;
 - (NSString *)primaryFontFamily;

package/ios/config/InputConfig.mm

@@ -4,6 +4,7 @@
 @implementation InputConfig {
   UIColor *_primaryColor;
   NSNumber *_primaryFontSize;
+  CGFloat _primaryLineHeight;
   NSString *_primaryFontWeight;
   NSString *_primaryFontFamily;
   UIFont *_primaryFont;
@@ -67,6 +68,7 @@
   InputConfig *copy = [[[self class] allocWithZone:zone] init];
   copy->_primaryColor = [_primaryColor copy];
   copy->_primaryFontSize = [_primaryFontSize copy];
+  copy->_primaryLineHeight = _primaryLineHeight;
   copy->_primaryFontWeight = [_primaryFontWeight copy];
   copy->_primaryFontFamily = [_primaryFontFamily copy];
   copy->_primaryFont = [_primaryFont copy];
@@ -135,6 +137,19 @@
   _olMarkerFontNeedsRecreation = YES;
 }
 
+- (CGFloat)primaryLineHeight {
+  return _primaryLineHeight;
+}
+
+- (void)setPrimaryLineHeight:(CGFloat)newValue {
+  _primaryLineHeight = newValue;
+}
+
+- (CGFloat)scaledPrimaryLineHeight {
+  return [[UIFontMetrics defaultMetrics]
+      scaledValueForValue:[self primaryLineHeight]];
+}
+
 - (NSString *)primaryFontWeight {
   return _primaryFontWeight != nullptr
              ? _primaryFontWeight

package/ios/extensions/LayoutManagerExtension.mm

@@ -283,6 +283,18 @@ static void const *kInputKey = &kInputKey;
                                                 NSTextContainer *container,
                                                 NSRange lineGlyphRange,
                                                 BOOL *stop) {
+                                     NSUInteger charIdx =
+                                         [self characterIndexForGlyphAtIndex:
+                                                   lineGlyphRange.location];
+                                     UIFont *font =
+                                         [typedInput->textView.textStorage
+                                                  attribute:NSFontAttributeName
+                                                    atIndex:charIdx
+                                             effectiveRange:nil];
+                                     CGRect textUsedRect =
+                                         [self getTextAlignedUsedRect:usedRect
+                                                                 font:font];
+
                                      NSString *markerFormat =
                                          pStyle.textLists.firstObject
                                              .markerFormat;
@@ -291,27 +303,23 @@ static void const *kInputKey = &kInputKey;
                                          NSTextListMarkerDecimal) {
                                        NSString *marker = [self
                                            getDecimalMarkerForList:typedInput
-                                                         charIndex:
-                                                             [self
-                                                                 characterIndexForGlyphAtIndex:
-                                                                     lineGlyphRange
-                                                                         .location]];
+                                                         charIndex:charIdx];
                                        [self drawDecimal:typedInput
                                                      marker:marker
                                            markerAttributes:markerAttributes
                                                      origin:origin
-                                                   usedRect:usedRect];
+                                                   usedRect:textUsedRect];
                                      } else if (markerFormat ==
                                                 NSTextListMarkerDisc) {
                                        [self drawBullet:typedInput
                                                  origin:origin
-                                               usedRect:usedRect];
+                                               usedRect:textUsedRect];
                                      } else if ([markerFormat
                                                     hasPrefix:@"{checkbox"]) {
                                        [self drawCheckbox:typedInput
                                              markerFormat:markerFormat
                                                    origin:origin
-                                                 usedRect:usedRect];
+                                                 usedRect:textUsedRect];
                                      }
                                      // only first line of a list gets its
                                      // marker drawn
@@ -363,6 +371,19 @@ static void const *kInputKey = &kInputKey;
   return [NSString stringWithFormat:@"%ld.", (long)(itemNumber)];
 }
 
+// Returns a usedRect adjusted to cover only the text portion of the line.
+// When minimumLineHeight expands the line box, extra space is added at the top
+// and text stays at the bottom. This strips that padding so markers align with
+// the text, not the full line box.
+- (CGRect)getTextAlignedUsedRect:(CGRect)usedRect font:(UIFont *)font {
+  if (font && usedRect.size.height > font.lineHeight) {
+    CGFloat extraSpace = usedRect.size.height - font.lineHeight;
+    usedRect.origin.y += extraSpace;
+    usedRect.size.height = font.lineHeight;
+  }
+  return usedRect;
+}
+
 - (void)drawCheckbox:(EnrichedTextInputView *)typedInput
         markerFormat:(NSString *)markerFormat
               origin:(CGPoint)origin
@@ -406,10 +427,12 @@ static void const *kInputKey = &kInputKey;
               origin:(CGPoint)origin
             usedRect:(CGRect)usedRect {
   CGFloat gapWidth = [typedInput->config orderedListGapWidth];
-  CGFloat markerWidth = [marker sizeWithAttributes:markerAttributes].width;
-  CGFloat markerX = usedRect.origin.x - gapWidth - markerWidth / 2;
+  CGSize markerSize = [marker sizeWithAttributes:markerAttributes];
+  CGFloat markerX = usedRect.origin.x - gapWidth - markerSize.width / 2;
+  CGFloat centerY = CGRectGetMidY(usedRect) + origin.y;
+  CGFloat markerY = centerY - markerSize.height / 2.0;
 
-  [marker drawAtPoint:CGPointMake(markerX, usedRect.origin.y + origin.y)
+  [marker drawAtPoint:CGPointMake(markerX, markerY)
        withAttributes:markerAttributes];
 }
 

package/ios/generated/ReactNativeEnrichedSpec/EventEmitters.cpp

@@ -273,4 +273,153 @@ imagesObject.setProperty(runtime, "height", imagesValue.height);
   });
 }
 
+
+void EnrichedTextInputViewEventEmitter::onContextMenuItemPress(OnContextMenuItemPress event) const {
+  dispatchEvent("contextMenuItemPress", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "itemText", event.itemText);
+payload.setProperty(runtime, "selectedText", event.selectedText);
+payload.setProperty(runtime, "selectionStart", event.selectionStart);
+payload.setProperty(runtime, "selectionEnd", event.selectionEnd);
+{
+  auto styleState = jsi::Object(runtime);
+  {
+    auto bold = jsi::Object(runtime);
+    bold.setProperty(runtime, "isActive", event.styleState.bold.isActive);
+    bold.setProperty(runtime, "isConflicting", event.styleState.bold.isConflicting);
+    bold.setProperty(runtime, "isBlocking", event.styleState.bold.isBlocking);
+    styleState.setProperty(runtime, "bold", bold);
+  }
+  {
+    auto italic = jsi::Object(runtime);
+    italic.setProperty(runtime, "isActive", event.styleState.italic.isActive);
+    italic.setProperty(runtime, "isConflicting", event.styleState.italic.isConflicting);
+    italic.setProperty(runtime, "isBlocking", event.styleState.italic.isBlocking);
+    styleState.setProperty(runtime, "italic", italic);
+  }
+  {
+    auto underline = jsi::Object(runtime);
+    underline.setProperty(runtime, "isActive", event.styleState.underline.isActive);
+    underline.setProperty(runtime, "isConflicting", event.styleState.underline.isConflicting);
+    underline.setProperty(runtime, "isBlocking", event.styleState.underline.isBlocking);
+    styleState.setProperty(runtime, "underline", underline);
+  }
+  {
+    auto strikeThrough = jsi::Object(runtime);
+    strikeThrough.setProperty(runtime, "isActive", event.styleState.strikeThrough.isActive);
+    strikeThrough.setProperty(runtime, "isConflicting", event.styleState.strikeThrough.isConflicting);
+    strikeThrough.setProperty(runtime, "isBlocking", event.styleState.strikeThrough.isBlocking);
+    styleState.setProperty(runtime, "strikeThrough", strikeThrough);
+  }
+  {
+    auto inlineCode = jsi::Object(runtime);
+    inlineCode.setProperty(runtime, "isActive", event.styleState.inlineCode.isActive);
+    inlineCode.setProperty(runtime, "isConflicting", event.styleState.inlineCode.isConflicting);
+    inlineCode.setProperty(runtime, "isBlocking", event.styleState.inlineCode.isBlocking);
+    styleState.setProperty(runtime, "inlineCode", inlineCode);
+  }
+  {
+    auto h1 = jsi::Object(runtime);
+    h1.setProperty(runtime, "isActive", event.styleState.h1.isActive);
+    h1.setProperty(runtime, "isConflicting", event.styleState.h1.isConflicting);
+    h1.setProperty(runtime, "isBlocking", event.styleState.h1.isBlocking);
+    styleState.setProperty(runtime, "h1", h1);
+  }
+  {
+    auto h2 = jsi::Object(runtime);
+    h2.setProperty(runtime, "isActive", event.styleState.h2.isActive);
+    h2.setProperty(runtime, "isConflicting", event.styleState.h2.isConflicting);
+    h2.setProperty(runtime, "isBlocking", event.styleState.h2.isBlocking);
+    styleState.setProperty(runtime, "h2", h2);
+  }
+  {
+    auto h3 = jsi::Object(runtime);
+    h3.setProperty(runtime, "isActive", event.styleState.h3.isActive);
+    h3.setProperty(runtime, "isConflicting", event.styleState.h3.isConflicting);
+    h3.setProperty(runtime, "isBlocking", event.styleState.h3.isBlocking);
+    styleState.setProperty(runtime, "h3", h3);
+  }
+  {
+    auto h4 = jsi::Object(runtime);
+    h4.setProperty(runtime, "isActive", event.styleState.h4.isActive);
+    h4.setProperty(runtime, "isConflicting", event.styleState.h4.isConflicting);
+    h4.setProperty(runtime, "isBlocking", event.styleState.h4.isBlocking);
+    styleState.setProperty(runtime, "h4", h4);
+  }
+  {
+    auto h5 = jsi::Object(runtime);
+    h5.setProperty(runtime, "isActive", event.styleState.h5.isActive);
+    h5.setProperty(runtime, "isConflicting", event.styleState.h5.isConflicting);
+    h5.setProperty(runtime, "isBlocking", event.styleState.h5.isBlocking);
+    styleState.setProperty(runtime, "h5", h5);
+  }
+  {
+    auto h6 = jsi::Object(runtime);
+    h6.setProperty(runtime, "isActive", event.styleState.h6.isActive);
+    h6.setProperty(runtime, "isConflicting", event.styleState.h6.isConflicting);
+    h6.setProperty(runtime, "isBlocking", event.styleState.h6.isBlocking);
+    styleState.setProperty(runtime, "h6", h6);
+  }
+  {
+    auto codeBlock = jsi::Object(runtime);
+    codeBlock.setProperty(runtime, "isActive", event.styleState.codeBlock.isActive);
+    codeBlock.setProperty(runtime, "isConflicting", event.styleState.codeBlock.isConflicting);
+    codeBlock.setProperty(runtime, "isBlocking", event.styleState.codeBlock.isBlocking);
+    styleState.setProperty(runtime, "codeBlock", codeBlock);
+  }
+  {
+    auto blockQuote = jsi::Object(runtime);
+    blockQuote.setProperty(runtime, "isActive", event.styleState.blockQuote.isActive);
+    blockQuote.setProperty(runtime, "isConflicting", event.styleState.blockQuote.isConflicting);
+    blockQuote.setProperty(runtime, "isBlocking", event.styleState.blockQuote.isBlocking);
+    styleState.setProperty(runtime, "blockQuote", blockQuote);
+  }
+  {
+    auto orderedList = jsi::Object(runtime);
+    orderedList.setProperty(runtime, "isActive", event.styleState.orderedList.isActive);
+    orderedList.setProperty(runtime, "isConflicting", event.styleState.orderedList.isConflicting);
+    orderedList.setProperty(runtime, "isBlocking", event.styleState.orderedList.isBlocking);
+    styleState.setProperty(runtime, "orderedList", orderedList);
+  }
+  {
+    auto unorderedList = jsi::Object(runtime);
+    unorderedList.setProperty(runtime, "isActive", event.styleState.unorderedList.isActive);
+    unorderedList.setProperty(runtime, "isConflicting", event.styleState.unorderedList.isConflicting);
+    unorderedList.setProperty(runtime, "isBlocking", event.styleState.unorderedList.isBlocking);
+    styleState.setProperty(runtime, "unorderedList", unorderedList);
+  }
+  {
+    auto link = jsi::Object(runtime);
+    link.setProperty(runtime, "isActive", event.styleState.link.isActive);
+    link.setProperty(runtime, "isConflicting", event.styleState.link.isConflicting);
+    link.setProperty(runtime, "isBlocking", event.styleState.link.isBlocking);
+    styleState.setProperty(runtime, "link", link);
+  }
+  {
+    auto image = jsi::Object(runtime);
+    image.setProperty(runtime, "isActive", event.styleState.image.isActive);
+    image.setProperty(runtime, "isConflicting", event.styleState.image.isConflicting);
+    image.setProperty(runtime, "isBlocking", event.styleState.image.isBlocking);
+    styleState.setProperty(runtime, "image", image);
+  }
+  {
+    auto mention = jsi::Object(runtime);
+    mention.setProperty(runtime, "isActive", event.styleState.mention.isActive);
+    mention.setProperty(runtime, "isConflicting", event.styleState.mention.isConflicting);
+    mention.setProperty(runtime, "isBlocking", event.styleState.mention.isBlocking);
+    styleState.setProperty(runtime, "mention", mention);
+  }
+  {
+    auto checkboxList = jsi::Object(runtime);
+    checkboxList.setProperty(runtime, "isActive", event.styleState.checkboxList.isActive);
+    checkboxList.setProperty(runtime, "isConflicting", event.styleState.checkboxList.isConflicting);
+    checkboxList.setProperty(runtime, "isBlocking", event.styleState.checkboxList.isBlocking);
+    styleState.setProperty(runtime, "checkboxList", checkboxList);
+  }
+  payload.setProperty(runtime, "styleState", styleState);
+}
+    return payload;
+  });
+}
+
 } // namespace facebook::react

package/ios/generated/ReactNativeEnrichedSpec/EventEmitters.h

@@ -212,6 +212,150 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
   struct OnPasteImages {
       std::vector<OnPasteImagesImages> images;
     };
+
+  struct OnContextMenuItemPressStyleStateBold {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateItalic {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateUnderline {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateStrikeThrough {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateInlineCode {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateH1 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateH2 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateH3 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateH4 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateH5 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateH6 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateCodeBlock {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateBlockQuote {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateOrderedList {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateUnorderedList {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateLink {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateImage {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateMention {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleStateCheckboxList {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnContextMenuItemPressStyleState {
+      OnContextMenuItemPressStyleStateBold bold;
+    OnContextMenuItemPressStyleStateItalic italic;
+    OnContextMenuItemPressStyleStateUnderline underline;
+    OnContextMenuItemPressStyleStateStrikeThrough strikeThrough;
+    OnContextMenuItemPressStyleStateInlineCode inlineCode;
+    OnContextMenuItemPressStyleStateH1 h1;
+    OnContextMenuItemPressStyleStateH2 h2;
+    OnContextMenuItemPressStyleStateH3 h3;
+    OnContextMenuItemPressStyleStateH4 h4;
+    OnContextMenuItemPressStyleStateH5 h5;
+    OnContextMenuItemPressStyleStateH6 h6;
+    OnContextMenuItemPressStyleStateCodeBlock codeBlock;
+    OnContextMenuItemPressStyleStateBlockQuote blockQuote;
+    OnContextMenuItemPressStyleStateOrderedList orderedList;
+    OnContextMenuItemPressStyleStateUnorderedList unorderedList;
+    OnContextMenuItemPressStyleStateLink link;
+    OnContextMenuItemPressStyleStateImage image;
+    OnContextMenuItemPressStyleStateMention mention;
+    OnContextMenuItemPressStyleStateCheckboxList checkboxList;
+    };
+
+  struct OnContextMenuItemPress {
+      std::string itemText;
+    std::string selectedText;
+    int selectionStart;
+    int selectionEnd;
+    OnContextMenuItemPressStyleState styleState;
+    };
   void onInputFocus(OnInputFocus value) const;
 
   void onInputBlur(OnInputBlur value) const;
@@ -235,5 +379,7 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
   void onInputKeyPress(OnInputKeyPress value) const;
 
   void onPasteImages(OnPasteImages value) const;
+
+  void onContextMenuItemPress(OnContextMenuItemPress value) const;
 };
 } // namespace facebook::react