react-native-enriched 0.2.0 → 0.3.0

package/ios/extensions/LayoutManagerExtension.mm

@@ -0,0 +1,396 @@
+#import "LayoutManagerExtension.h"
+#import "ColorExtension.h"
+#import "EnrichedTextInputView.h"
+#import "ParagraphsUtils.h"
+#import "StyleHeaders.h"
+#import <objc/runtime.h>
+
+@implementation NSLayoutManager (LayoutManagerExtension)
+
+static void const *kInputKey = &kInputKey;
+
+- (id)input {
+  return objc_getAssociatedObject(self, kInputKey);
+}
+
+- (void)setInput:(id)value {
+  objc_setAssociatedObject(self, kInputKey, value,
+                           OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    Class myClass = [NSLayoutManager class];
+    SEL originalSelector = @selector(drawBackgroundForGlyphRange:atPoint:);
+    SEL swizzledSelector = @selector(my_drawBackgroundForGlyphRange:atPoint:);
+    Method originalMethod = class_getInstanceMethod(myClass, originalSelector);
+    Method swizzledMethod = class_getInstanceMethod(myClass, swizzledSelector);
+
+    BOOL didAddMethod = class_addMethod(
+        myClass, originalSelector, method_getImplementation(swizzledMethod),
+        method_getTypeEncoding(swizzledMethod));
+
+    if (didAddMethod) {
+      class_replaceMethod(myClass, swizzledSelector,
+                          method_getImplementation(originalMethod),
+                          method_getTypeEncoding(originalMethod));
+    } else {
+      method_exchangeImplementations(originalMethod, swizzledMethod);
+    }
+  });
+}
+
+- (void)my_drawBackgroundForGlyphRange:(NSRange)glyphRange
+                               atPoint:(CGPoint)origin {
+  [self my_drawBackgroundForGlyphRange:glyphRange atPoint:origin];
+
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)self.input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  NSRange visibleCharRange = [self characterRangeForGlyphRange:glyphRange
+                                              actualGlyphRange:NULL];
+
+  [self drawBlockQuotes:typedInput
+                 origin:origin
+       visibleCharRange:visibleCharRange];
+  [self drawLists:typedInput origin:origin visibleCharRange:visibleCharRange];
+  [self drawCodeBlocks:typedInput
+                origin:origin
+      visibleCharRange:visibleCharRange];
+}
+
+- (void)drawCodeBlocks:(EnrichedTextInputView *)typedInput
+                origin:(CGPoint)origin
+      visibleCharRange:(NSRange)visibleCharRange {
+  CodeBlockStyle *codeBlockStyle =
+      typedInput->stylesDict[@([CodeBlockStyle getStyleType])];
+  if (codeBlockStyle == nullptr) {
+    return;
+  }
+
+  NSArray<StylePair *> *allCodeBlocks =
+      [codeBlockStyle findAllOccurences:visibleCharRange];
+  NSArray<StylePair *> *mergedCodeBlocks =
+      [self mergeContiguousStylePairs:allCodeBlocks];
+  UIColor *bgColor = [[typedInput->config codeBlockBgColor]
+      colorWithAlphaIfNotTransparent:0.4];
+  CGFloat radius = [typedInput->config codeBlockBorderRadius];
+  [bgColor setFill];
+
+  for (StylePair *pair in mergedCodeBlocks) {
+    NSRange blockCharacterRange = [pair.rangeValue rangeValue];
+    if (blockCharacterRange.length == 0)
+      continue;
+
+    NSArray *paragraphs =
+        [ParagraphsUtils getSeparateParagraphsRangesIn:typedInput->textView
+                                                 range:blockCharacterRange];
+    if (paragraphs.count == 0)
+      continue;
+
+    NSRange firstParagraphRange =
+        [((NSValue *)[paragraphs firstObject]) rangeValue];
+    NSRange lastParagraphRange =
+        [((NSValue *)[paragraphs lastObject]) rangeValue];
+
+    for (NSValue *paragraphValue in paragraphs) {
+      NSRange paragraphCharacterRange = [paragraphValue rangeValue];
+
+      BOOL isFirstParagraph =
+          NSEqualRanges(paragraphCharacterRange, firstParagraphRange);
+      BOOL isLastParagraph =
+          NSEqualRanges(paragraphCharacterRange, lastParagraphRange);
+
+      NSRange paragraphGlyphRange =
+          [self glyphRangeForCharacterRange:paragraphCharacterRange
+                       actualCharacterRange:NULL];
+
+      __block BOOL isFirstLineOfParagraph = YES;
+
+      [self
+          enumerateLineFragmentsForGlyphRange:paragraphGlyphRange
+                                   usingBlock:^(
+                                       CGRect rect, CGRect usedRect,
+                                       NSTextContainer *_Nonnull textContainer,
+                                       NSRange glyphRange,
+                                       BOOL *_Nonnull stop) {
+                                     CGRect lineBgRect = rect;
+                                     lineBgRect.origin.x = origin.x;
+                                     lineBgRect.origin.y += origin.y;
+                                     lineBgRect.size.width =
+                                         textContainer.size.width;
+
+                                     UIRectCorner cornersForThisLine = 0;
+
+                                     if (isFirstParagraph &&
+                                         isFirstLineOfParagraph) {
+                                       cornersForThisLine =
+                                           UIRectCornerTopLeft |
+                                           UIRectCornerTopRight;
+                                     }
+
+                                     BOOL isLastLineOfParagraph =
+                                         (NSMaxRange(glyphRange) >=
+                                          NSMaxRange(paragraphGlyphRange));
+
+                                     if (isLastParagraph &&
+                                         isLastLineOfParagraph) {
+                                       cornersForThisLine =
+                                           cornersForThisLine |
+                                           UIRectCornerBottomLeft |
+                                           UIRectCornerBottomRight;
+                                     }
+
+                                     UIBezierPath *path = [UIBezierPath
+                                         bezierPathWithRoundedRect:lineBgRect
+                                                 byRoundingCorners:
+                                                     cornersForThisLine
+                                                       cornerRadii:CGSizeMake(
+                                                                       radius,
+                                                                       radius)];
+                                     [path fill];
+
+                                     isFirstLineOfParagraph = NO;
+                                   }];
+    }
+  }
+}
+
+- (NSArray<StylePair *> *)mergeContiguousStylePairs:
+    (NSArray<StylePair *> *)pairs {
+  if (pairs.count == 0) {
+    return @[];
+  }
+
+  NSMutableArray<StylePair *> *mergedPairs = [[NSMutableArray alloc] init];
+  StylePair *currentPair = pairs[0];
+  NSRange currentRange = [currentPair.rangeValue rangeValue];
+  for (NSUInteger i = 1; i < pairs.count; i++) {
+    StylePair *nextPair = pairs[i];
+    NSRange nextRange = [nextPair.rangeValue rangeValue];
+
+    // The Gap Check:
+    // NSMaxRange(currentRange) is where the current block ends.
+    // nextRange.location is where the next block starts.
+    if (NSMaxRange(currentRange) == nextRange.location) {
+      // They touch perfectly (no gap). Merge them.
+      currentRange.length += nextRange.length;
+    } else {
+      // There is a gap (indices don't match).
+      // 1. Save the finished block.
+      StylePair *mergedPair = [[StylePair alloc] init];
+      mergedPair.rangeValue = [NSValue valueWithRange:currentRange];
+      mergedPair.styleValue = currentPair.styleValue;
+      [mergedPairs addObject:mergedPair];
+
+      // 2. Start a brand new block.
+      currentPair = nextPair;
+      currentRange = nextRange;
+    }
+  }
+
+  // Add the final block
+  StylePair *lastPair = [[StylePair alloc] init];
+  lastPair.rangeValue = [NSValue valueWithRange:currentRange];
+  lastPair.styleValue = currentPair.styleValue;
+  [mergedPairs addObject:lastPair];
+
+  return mergedPairs;
+}
+
+- (void)drawBlockQuotes:(EnrichedTextInputView *)typedInput
+                 origin:(CGPoint)origin
+       visibleCharRange:(NSRange)visibleCharRange {
+  BlockQuoteStyle *bqStyle =
+      typedInput->stylesDict[@([BlockQuoteStyle getStyleType])];
+  if (bqStyle == nullptr) {
+    return;
+  }
+
+  NSArray *allBlockquotes = [bqStyle findAllOccurences:visibleCharRange];
+
+  for (StylePair *pair in allBlockquotes) {
+    NSRange paragraphRange = [typedInput->textView.textStorage.string
+        paragraphRangeForRange:[pair.rangeValue rangeValue]];
+    NSRange paragraphGlyphRange =
+        [self glyphRangeForCharacterRange:paragraphRange
+                     actualCharacterRange:nullptr];
+    [self
+        enumerateLineFragmentsForGlyphRange:paragraphGlyphRange
+                                 usingBlock:^(
+                                     CGRect rect, CGRect usedRect,
+                                     NSTextContainer *_Nonnull textContainer,
+                                     NSRange glyphRange, BOOL *_Nonnull stop) {
+                                   CGFloat paddingLeft = origin.x;
+                                   CGFloat paddingTop = origin.y;
+                                   CGFloat x = paddingLeft;
+                                   CGFloat y = paddingTop + rect.origin.y;
+                                   CGFloat width =
+                                       [typedInput
+                                               ->config blockquoteBorderWidth];
+                                   CGFloat height = rect.size.height;
+
+                                   CGRect lineRect =
+                                       CGRectMake(x, y, width, height);
+                                   [[typedInput->config blockquoteBorderColor]
+                                       setFill];
+                                   UIRectFill(lineRect);
+                                 }];
+  }
+}
+
+- (void)drawLists:(EnrichedTextInputView *)typedInput
+              origin:(CGPoint)origin
+    visibleCharRange:(NSRange)visibleCharRange {
+  UnorderedListStyle *ulStyle =
+      typedInput->stylesDict[@([UnorderedListStyle getStyleType])];
+  OrderedListStyle *olStyle =
+      typedInput->stylesDict[@([OrderedListStyle getStyleType])];
+  if (ulStyle == nullptr || olStyle == nullptr) {
+    return;
+  }
+
+  NSMutableArray *allLists = [[NSMutableArray alloc] init];
+  [allLists addObjectsFromArray:[ulStyle findAllOccurences:visibleCharRange]];
+  [allLists addObjectsFromArray:[olStyle findAllOccurences:visibleCharRange]];
+
+  for (StylePair *pair in allLists) {
+    NSParagraphStyle *pStyle = (NSParagraphStyle *)pair.styleValue;
+    NSDictionary *markerAttributes = @{
+      NSFontAttributeName : [typedInput->config orderedListMarkerFont],
+      NSForegroundColorAttributeName :
+          [typedInput->config orderedListMarkerColor]
+    };
+
+    NSArray *paragraphs = [ParagraphsUtils
+        getSeparateParagraphsRangesIn:typedInput->textView
+                                range:[pair.rangeValue rangeValue]];
+
+    for (NSValue *paragraph in paragraphs) {
+      NSRange paragraphGlyphRange =
+          [self glyphRangeForCharacterRange:[paragraph rangeValue]
+                       actualCharacterRange:nullptr];
+
+      [self
+          enumerateLineFragmentsForGlyphRange:paragraphGlyphRange
+                                   usingBlock:^(CGRect rect, CGRect usedRect,
+                                                NSTextContainer *container,
+                                                NSRange lineGlyphRange,
+                                                BOOL *stop) {
+                                     NSString *marker = [self
+                                         markerForList:pStyle.textLists
+                                                           .firstObject
+                                             charIndex:
+                                                 [self
+                                                     characterIndexForGlyphAtIndex:
+                                                         lineGlyphRange
+                                                             .location]
+                                                 input:typedInput];
+
+                                     if (pStyle.textLists.firstObject
+                                             .markerFormat ==
+                                         NSTextListMarkerDecimal) {
+                                       CGFloat gapWidth =
+                                           [typedInput->config
+                                                   orderedListGapWidth];
+                                       CGFloat markerWidth =
+                                           [marker sizeWithAttributes:
+                                                       markerAttributes]
+                                               .width;
+                                       CGFloat markerX = usedRect.origin.x -
+                                                         gapWidth -
+                                                         markerWidth / 2;
+
+                                       [marker drawAtPoint:CGPointMake(
+                                                               markerX,
+                                                               usedRect.origin
+                                                                       .y +
+                                                                   origin.y)
+                                            withAttributes:markerAttributes];
+                                     } else {
+                                       CGFloat gapWidth =
+                                           [typedInput->config
+                                                   unorderedListGapWidth];
+                                       CGFloat bulletSize =
+                                           [typedInput->config
+                                                   unorderedListBulletSize];
+                                       CGFloat bulletX = usedRect.origin.x -
+                                                         gapWidth -
+                                                         bulletSize / 2;
+                                       CGFloat centerY =
+                                           CGRectGetMidY(usedRect);
+
+                                       CGContextRef context =
+                                           UIGraphicsGetCurrentContext();
+                                       CGContextSaveGState(context);
+                                       {
+                                         [[typedInput->config
+                                                 unorderedListBulletColor]
+                                             setFill];
+                                         CGContextAddArc(
+                                             context, bulletX, centerY,
+                                             bulletSize / 2, 0, 2 * M_PI, YES);
+                                         CGContextFillPath(context);
+                                       }
+                                       CGContextRestoreGState(context);
+                                     }
+                                     // only first line of a list gets its
+                                     // marker drawn
+                                     *stop = YES;
+                                   }];
+    }
+  }
+}
+
+- (NSString *)markerForList:(NSTextList *)list
+                  charIndex:(NSUInteger)index
+                      input:(EnrichedTextInputView *)input {
+  if (list.markerFormat == NSTextListMarkerDecimal) {
+    NSString *fullText = input->textView.textStorage.string;
+    NSInteger itemNumber = 1;
+
+    NSRange currentParagraph =
+        [fullText paragraphRangeForRange:NSMakeRange(index, 0)];
+    if (currentParagraph.location > 0) {
+      OrderedListStyle *olStyle =
+          input->stylesDict[@([OrderedListStyle getStyleType])];
+
+      NSInteger prevParagraphsCount = 0;
+      NSInteger recentParagraphLocation =
+          [fullText
+              paragraphRangeForRange:NSMakeRange(currentParagraph.location - 1,
+                                                 0)]
+              .location;
+
+      // seek for previous lists
+      while (true) {
+        if ([olStyle detectStyle:NSMakeRange(recentParagraphLocation, 0)]) {
+          prevParagraphsCount += 1;
+
+          if (recentParagraphLocation > 0) {
+            recentParagraphLocation =
+                [fullText
+                    paragraphRangeForRange:NSMakeRange(
+                                               recentParagraphLocation - 1, 0)]
+                    .location;
+          } else {
+            break;
+          }
+        } else {
+          break;
+        }
+      }
+
+      itemNumber = prevParagraphsCount + 1;
+    }
+
+    return [NSString stringWithFormat:@"%ld.", (long)(itemNumber)];
+  } else {
+    return @"•";
+  }
+}
+
+@end

package/ios/{utils → extensions}/StringExtension.mm

@@ -13,41 +13,44 @@
 + (NSString *)stringByEscapingHtml:(NSString *)html {
   NSMutableString *escaped = [html mutableCopy];
   NSDictionary *escapeMap = @{
-    @"&": @"&",
-    @"<": @"&lt;",
-    @">": @"&gt;",
+    @"&" : @"&amp;",
+    @"<" : @"&lt;",
+    @">" : @"&gt;",
   };
-  
-  for(NSString *key in escapeMap) {
-    [escaped replaceOccurrencesOfString:key withString:escapeMap[key] options:NSLiteralSearch range:NSMakeRange(0, escaped.length)];
+
+  for (NSString *key in escapeMap) {
+    [escaped replaceOccurrencesOfString:key
+                             withString:escapeMap[key]
+                                options:NSLiteralSearch
+                                  range:NSMakeRange(0, escaped.length)];
   }
   return escaped;
 }
 
 + (NSDictionary *)getEscapedCharactersInfoFrom:(NSString *)text {
   NSDictionary *unescapeMap = @{
-    @"&amp;": @"&",
-    @"&lt;": @"<",
-    @"&gt;": @">",
+    @"&amp;" : @"&",
+    @"&lt;" : @"<",
+    @"&gt;" : @">",
   };
-  
+
   NSMutableDictionary *results = [[NSMutableDictionary alloc] init];
-  
-  for(NSString *key in unescapeMap) {
+
+  for (NSString *key in unescapeMap) {
     NSRange searchRange = NSMakeRange(0, text.length);
     NSRange foundRange;
 
-    while(searchRange.location < text.length) {
+    while (searchRange.location < text.length) {
       foundRange = [text rangeOfString:key options:0 range:searchRange];
-      if(foundRange.location == NSNotFound) {
+      if (foundRange.location == NSNotFound) {
         break;
       }
-      results[@(foundRange.location)] = @[key, unescapeMap[key]];
+      results[@(foundRange.location)] = @[ key, unescapeMap[key] ];
       searchRange.location = foundRange.location + foundRange.length;
       searchRange.length = text.length - searchRange.location;
     }
   }
-  
+
   return results;
 }
 

package/ios/generated/RNEnrichedTextInputViewSpec/EventEmitters.cpp

@@ -51,6 +51,140 @@ void EnrichedTextInputViewEventEmitter::onChangeHtml(OnChangeHtml event) const {
 
 void EnrichedTextInputViewEventEmitter::onChangeState(OnChangeState event) const {
   dispatchEvent("changeState", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    {
+  auto bold = jsi::Object(runtime);
+  bold.setProperty(runtime, "isActive", event.bold.isActive);
+  bold.setProperty(runtime, "isConflicting", event.bold.isConflicting);
+  bold.setProperty(runtime, "isBlocking", event.bold.isBlocking);
+  payload.setProperty(runtime, "bold", bold);
+}
+{
+  auto italic = jsi::Object(runtime);
+  italic.setProperty(runtime, "isActive", event.italic.isActive);
+  italic.setProperty(runtime, "isConflicting", event.italic.isConflicting);
+  italic.setProperty(runtime, "isBlocking", event.italic.isBlocking);
+  payload.setProperty(runtime, "italic", italic);
+}
+{
+  auto underline = jsi::Object(runtime);
+  underline.setProperty(runtime, "isActive", event.underline.isActive);
+  underline.setProperty(runtime, "isConflicting", event.underline.isConflicting);
+  underline.setProperty(runtime, "isBlocking", event.underline.isBlocking);
+  payload.setProperty(runtime, "underline", underline);
+}
+{
+  auto strikeThrough = jsi::Object(runtime);
+  strikeThrough.setProperty(runtime, "isActive", event.strikeThrough.isActive);
+  strikeThrough.setProperty(runtime, "isConflicting", event.strikeThrough.isConflicting);
+  strikeThrough.setProperty(runtime, "isBlocking", event.strikeThrough.isBlocking);
+  payload.setProperty(runtime, "strikeThrough", strikeThrough);
+}
+{
+  auto inlineCode = jsi::Object(runtime);
+  inlineCode.setProperty(runtime, "isActive", event.inlineCode.isActive);
+  inlineCode.setProperty(runtime, "isConflicting", event.inlineCode.isConflicting);
+  inlineCode.setProperty(runtime, "isBlocking", event.inlineCode.isBlocking);
+  payload.setProperty(runtime, "inlineCode", inlineCode);
+}
+{
+  auto h1 = jsi::Object(runtime);
+  h1.setProperty(runtime, "isActive", event.h1.isActive);
+  h1.setProperty(runtime, "isConflicting", event.h1.isConflicting);
+  h1.setProperty(runtime, "isBlocking", event.h1.isBlocking);
+  payload.setProperty(runtime, "h1", h1);
+}
+{
+  auto h2 = jsi::Object(runtime);
+  h2.setProperty(runtime, "isActive", event.h2.isActive);
+  h2.setProperty(runtime, "isConflicting", event.h2.isConflicting);
+  h2.setProperty(runtime, "isBlocking", event.h2.isBlocking);
+  payload.setProperty(runtime, "h2", h2);
+}
+{
+  auto h3 = jsi::Object(runtime);
+  h3.setProperty(runtime, "isActive", event.h3.isActive);
+  h3.setProperty(runtime, "isConflicting", event.h3.isConflicting);
+  h3.setProperty(runtime, "isBlocking", event.h3.isBlocking);
+  payload.setProperty(runtime, "h3", h3);
+}
+{
+  auto h4 = jsi::Object(runtime);
+  h4.setProperty(runtime, "isActive", event.h4.isActive);
+  h4.setProperty(runtime, "isConflicting", event.h4.isConflicting);
+  h4.setProperty(runtime, "isBlocking", event.h4.isBlocking);
+  payload.setProperty(runtime, "h4", h4);
+}
+{
+  auto h5 = jsi::Object(runtime);
+  h5.setProperty(runtime, "isActive", event.h5.isActive);
+  h5.setProperty(runtime, "isConflicting", event.h5.isConflicting);
+  h5.setProperty(runtime, "isBlocking", event.h5.isBlocking);
+  payload.setProperty(runtime, "h5", h5);
+}
+{
+  auto h6 = jsi::Object(runtime);
+  h6.setProperty(runtime, "isActive", event.h6.isActive);
+  h6.setProperty(runtime, "isConflicting", event.h6.isConflicting);
+  h6.setProperty(runtime, "isBlocking", event.h6.isBlocking);
+  payload.setProperty(runtime, "h6", h6);
+}
+{
+  auto codeBlock = jsi::Object(runtime);
+  codeBlock.setProperty(runtime, "isActive", event.codeBlock.isActive);
+  codeBlock.setProperty(runtime, "isConflicting", event.codeBlock.isConflicting);
+  codeBlock.setProperty(runtime, "isBlocking", event.codeBlock.isBlocking);
+  payload.setProperty(runtime, "codeBlock", codeBlock);
+}
+{
+  auto blockQuote = jsi::Object(runtime);
+  blockQuote.setProperty(runtime, "isActive", event.blockQuote.isActive);
+  blockQuote.setProperty(runtime, "isConflicting", event.blockQuote.isConflicting);
+  blockQuote.setProperty(runtime, "isBlocking", event.blockQuote.isBlocking);
+  payload.setProperty(runtime, "blockQuote", blockQuote);
+}
+{
+  auto orderedList = jsi::Object(runtime);
+  orderedList.setProperty(runtime, "isActive", event.orderedList.isActive);
+  orderedList.setProperty(runtime, "isConflicting", event.orderedList.isConflicting);
+  orderedList.setProperty(runtime, "isBlocking", event.orderedList.isBlocking);
+  payload.setProperty(runtime, "orderedList", orderedList);
+}
+{
+  auto unorderedList = jsi::Object(runtime);
+  unorderedList.setProperty(runtime, "isActive", event.unorderedList.isActive);
+  unorderedList.setProperty(runtime, "isConflicting", event.unorderedList.isConflicting);
+  unorderedList.setProperty(runtime, "isBlocking", event.unorderedList.isBlocking);
+  payload.setProperty(runtime, "unorderedList", unorderedList);
+}
+{
+  auto link = jsi::Object(runtime);
+  link.setProperty(runtime, "isActive", event.link.isActive);
+  link.setProperty(runtime, "isConflicting", event.link.isConflicting);
+  link.setProperty(runtime, "isBlocking", event.link.isBlocking);
+  payload.setProperty(runtime, "link", link);
+}
+{
+  auto image = jsi::Object(runtime);
+  image.setProperty(runtime, "isActive", event.image.isActive);
+  image.setProperty(runtime, "isConflicting", event.image.isConflicting);
+  image.setProperty(runtime, "isBlocking", event.image.isBlocking);
+  payload.setProperty(runtime, "image", image);
+}
+{
+  auto mention = jsi::Object(runtime);
+  mention.setProperty(runtime, "isActive", event.mention.isActive);
+  mention.setProperty(runtime, "isConflicting", event.mention.isConflicting);
+  mention.setProperty(runtime, "isBlocking", event.mention.isBlocking);
+  payload.setProperty(runtime, "mention", mention);
+}
+    return payload;
+  });
+}
+
+
+void EnrichedTextInputViewEventEmitter::onChangeStateDeprecated(OnChangeStateDeprecated event) const {
+  dispatchEvent("changeStateDeprecated", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);
     payload.setProperty(runtime, "isBold", event.isBold);
 payload.setProperty(runtime, "isItalic", event.isItalic);
@@ -60,6 +194,9 @@ payload.setProperty(runtime, "isInlineCode", event.isInlineCode);
 payload.setProperty(runtime, "isH1", event.isH1);
 payload.setProperty(runtime, "isH2", event.isH2);
 payload.setProperty(runtime, "isH3", event.isH3);
+payload.setProperty(runtime, "isH4", event.isH4);
+payload.setProperty(runtime, "isH5", event.isH5);
+payload.setProperty(runtime, "isH6", event.isH6);
 payload.setProperty(runtime, "isCodeBlock", event.isCodeBlock);
 payload.setProperty(runtime, "isBlockQuote", event.isBlockQuote);
 payload.setProperty(runtime, "isOrderedList", event.isOrderedList);
@@ -115,4 +252,23 @@ payload.setProperty(runtime, "text", event.text);
   });
 }
 
+
+void EnrichedTextInputViewEventEmitter::onRequestHtmlResult(OnRequestHtmlResult event) const {
+  dispatchEvent("requestHtmlResult", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "requestId", event.requestId);
+payload.setProperty(runtime, "html", jsi::valueFromDynamic(runtime, event.html));
+    return payload;
+  });
+}
+
+
+void EnrichedTextInputViewEventEmitter::onInputKeyPress(OnInputKeyPress event) const {
+  dispatchEvent("inputKeyPress", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "key", event.key);
+    return payload;
+  });
+}
+
 } // namespace facebook::react