react-native-enriched 0.0.0 → 0.1.1

package/ios/styles/StrikethroughStyle.mm

@@ -0,0 +1,80 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "OccurenceUtils.h"
+
+@implementation StrikethroughStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return Strikethrough; }
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  return self;
+}
+
+- (void)applyStyle:(NSRange)range {
+  BOOL isStylePresent = [self detectStyle: range];
+  if(range.length >= 1) {
+    isStylePresent ? [self removeAttributes:range] : [self addAttributes:range];
+  } else {
+    isStylePresent ? [self removeTypingAttributes] : [self addTypingAttributes];
+  }
+}
+
+- (void)addAttributes:(NSRange)range {
+  [_input->textView.textStorage addAttribute:NSStrikethroughStyleAttributeName value:@(NSUnderlineStyleSingle) range:range];
+}
+
+- (void)addTypingAttributes {
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  newTypingAttrs[NSStrikethroughStyleAttributeName] = @(NSUnderlineStyleSingle);
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (void)removeAttributes:(NSRange)range {
+  [_input->textView.textStorage removeAttribute:NSStrikethroughStyleAttributeName range:range];
+}
+
+- (void)removeTypingAttributes {
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  [newTypingAttrs removeObjectForKey: NSStrikethroughStyleAttributeName];
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  NSNumber *strikethroughStyle = (NSNumber *)value;
+  return strikethroughStyle != nullptr && [strikethroughStyle intValue] != NSUnderlineStyleNone;
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    return [OccurenceUtils detect:NSStrikethroughStyleAttributeName withInput:_input inRange:range
+      withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  } else {
+    NSNumber *currenStrikethroughAttr = (NSNumber *)_input->textView.typingAttributes[NSStrikethroughStyleAttributeName];
+    return currenStrikethroughAttr != nullptr;
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:NSStrikethroughStyleAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+- (NSArray<StylePair *> *_Nullable)findAllOccurences:(NSRange)range {
+  return [OccurenceUtils all:NSStrikethroughStyleAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+@end

package/ios/styles/UnderlineStyle.mm

@@ -0,0 +1,112 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "OccurenceUtils.h"
+
+@implementation UnderlineStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return Underline; }
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  return self;
+}
+
+- (void)applyStyle:(NSRange)range {
+  BOOL isStylePresent = [self detectStyle: range];
+  if(range.length >= 1) {
+    isStylePresent ? [self removeAttributes:range] : [self addAttributes:range];
+  } else {
+    isStylePresent ? [self removeTypingAttributes] : [self addTypingAttributes];
+  }
+}
+
+- (void)addAttributes:(NSRange)range {
+  [_input->textView.textStorage addAttribute:NSUnderlineStyleAttributeName value:@(NSUnderlineStyleSingle) range:range];
+}
+
+- (void)addTypingAttributes {
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  newTypingAttrs[NSUnderlineStyleAttributeName] = @(NSUnderlineStyleSingle);
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (void)removeAttributes:(NSRange)range {
+  [_input->textView.textStorage removeAttribute:NSUnderlineStyleAttributeName range:range];
+}
+
+- (void)removeTypingAttributes {
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  [newTypingAttrs removeObjectForKey: NSUnderlineStyleAttributeName];
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (BOOL)underlinedLinkConflictsInRange:(NSRange)range {
+  BOOL conflicted = NO;
+  if([_input->config linkDecorationLine] == DecorationUnderline) {
+    LinkStyle *linkStyle = _input->stylesDict[@([LinkStyle getStyleType])];
+    conflicted = range.length > 0
+      ? [linkStyle anyOccurence:range]
+      : [linkStyle detectStyle:range];
+  }
+  return conflicted;
+}
+
+- (BOOL)underlinedMentionConflictsInRange:(NSRange)range {
+  BOOL conflicted = NO;
+  MentionStyle *mentionStyle = _input->stylesDict[@([MentionStyle getStyleType])];
+  if(range.length == 0) {
+    if([mentionStyle detectStyle:range]) {
+      MentionParams *params = [mentionStyle getMentionParamsAt:range.location];
+      conflicted = [_input->config mentionStylePropsForIndicator:params.indicator].decorationLine == DecorationUnderline;
+    }
+  } else {
+    NSArray *occurences = [mentionStyle findAllOccurences:range];
+    for(StylePair *pair in occurences) {
+      MentionParams *params = [mentionStyle getMentionParamsAt:[pair.rangeValue rangeValue].location];
+      if([_input->config mentionStylePropsForIndicator:params.indicator].decorationLine == DecorationUnderline) {
+        conflicted = YES;
+        break;
+      }
+    }
+  }
+  return conflicted;
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  NSNumber *underlineStyle = (NSNumber *)value;
+  return underlineStyle != nullptr && [underlineStyle intValue] != NSUnderlineStyleNone && ![self underlinedLinkConflictsInRange:range] && ![self underlinedMentionConflictsInRange:range];
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    return [OccurenceUtils detect:NSUnderlineStyleAttributeName withInput:_input inRange:range
+      withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  } else {
+    NSNumber *currentUnderlineAttr = (NSNumber *)_input->textView.typingAttributes[NSUnderlineStyleAttributeName];
+    return [self styleCondition:currentUnderlineAttr :range];
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:NSUnderlineStyleAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+- (NSArray<StylePair *> *_Nullable)findAllOccurences:(NSRange)range {
+  return [OccurenceUtils all:NSUnderlineStyleAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+@end

package/ios/styles/UnorderedListStyle.mm

@@ -0,0 +1,225 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "FontExtension.h"
+#import "OccurenceUtils.h"
+#import "ParagraphsUtils.h"
+#import "TextInsertionUtils.h"
+
+@implementation UnorderedListStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return UnorderedList; }
+
+- (CGFloat)getHeadIndent {
+  // lists are drawn manually
+  // margin before bullet + gap between bullet and paragraph
+  return [_input->config unorderedListMarginLeft] + [_input->config unorderedListGapWidth];
+}
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  return self;
+}
+
+- (void)applyStyle:(NSRange)range {
+  BOOL isStylePresent = [self detectStyle:range];
+  if(range.length >= 1) {
+    isStylePresent ? [self removeAttributes:range] : [self addAttributes:range];
+  } else {
+    isStylePresent ? [self removeTypingAttributes] : [self addTypingAttributes];
+  }
+}
+
+// we assume correct paragraph range is already given
+- (void)addAttributes:(NSRange)range {
+  NSTextList *bullet = [[NSTextList alloc] initWithMarkerFormat:NSTextListMarkerDisc options:0];
+  NSArray *paragraphs = [ParagraphsUtils getSeparateParagraphsRangesIn:_input->textView range:range];
+  // if we fill empty lines with zero width spaces, we need to offset later ranges
+  NSInteger offset = 0;
+  // needed for range adjustments
+  NSRange preModificationRange = _input->textView.selectedRange;
+  
+  // let's not emit some weird selection changes or text/html changes
+  _input->blockEmitting = YES;
+  
+  for(NSValue *value in paragraphs) {
+    // take previous offsets into consideration
+    NSRange fixedRange = NSMakeRange([value rangeValue].location + offset, [value rangeValue].length);
+    
+    // length 0 with first line, length 1 and newline with some empty lines in the middle
+    if(fixedRange.length == 0 ||
+      (fixedRange.length == 1 &&
+      [[NSCharacterSet newlineCharacterSet] characterIsMember: [_input->textView.textStorage.string characterAtIndex:fixedRange.location]])
+    ) {
+      [TextInsertionUtils insertText:@"\u200B" at:fixedRange.location additionalAttributes:nullptr input:_input withSelection:NO];
+      fixedRange = NSMakeRange(fixedRange.location, fixedRange.length + 1);
+      offset += 1;
+    }
+    
+    [_input->textView.textStorage enumerateAttribute:NSParagraphStyleAttributeName inRange:fixedRange options:0
+      usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+        NSMutableParagraphStyle *pStyle = [(NSParagraphStyle *)value mutableCopy];
+        pStyle.textLists = @[bullet];
+        pStyle.headIndent = [self getHeadIndent];
+        pStyle.firstLineHeadIndent = [self getHeadIndent];
+        [_input->textView.textStorage addAttribute:NSParagraphStyleAttributeName value:pStyle range:range];
+      }
+    ];
+  }
+  
+  // back to emitting
+  _input->blockEmitting = NO;
+  
+  if(preModificationRange.length == 0) {
+    // fix selection if only one line was possibly made a list and filled with a space
+    _input->textView.selectedRange = preModificationRange;
+  } else {
+    // in other cases, fix the selection with newly made offsets
+    _input->textView.selectedRange = NSMakeRange(preModificationRange.location, preModificationRange.length + offset);
+  }
+  
+  // also add typing attributes
+  NSMutableDictionary *typingAttrs = [_input->textView.typingAttributes mutableCopy];
+  NSMutableParagraphStyle *pStyle = [typingAttrs[NSParagraphStyleAttributeName] mutableCopy];
+  pStyle.textLists = @[bullet];
+  pStyle.headIndent = [self getHeadIndent];
+  pStyle.firstLineHeadIndent = [self getHeadIndent];
+  typingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  _input->textView.typingAttributes = typingAttrs;
+}
+
+// does pretty much the same as normal addAttributes, just need to get the range
+- (void)addTypingAttributes {
+  [self addAttributes:_input->textView.selectedRange];
+}
+
+- (void)removeAttributes:(NSRange)range {
+  NSArray *paragraphs = [ParagraphsUtils getSeparateParagraphsRangesIn:_input->textView range:range];
+  
+  [_input->textView.textStorage beginEditing];
+  
+  for(NSValue *value in paragraphs) {
+    NSRange range = [value rangeValue];
+    [_input->textView.textStorage enumerateAttribute:NSParagraphStyleAttributeName inRange:range options:0
+      usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+        NSMutableParagraphStyle *pStyle = [(NSParagraphStyle *)value mutableCopy];
+        pStyle.textLists = @[];
+        pStyle.headIndent = 0;
+        pStyle.firstLineHeadIndent = 0;
+        [_input->textView.textStorage addAttribute:NSParagraphStyleAttributeName value:pStyle range:range];
+      }
+    ];
+  }
+  
+  [_input->textView.textStorage endEditing];
+    
+  // also remove typing attributes
+  NSMutableDictionary *typingAttrs = [_input->textView.typingAttributes mutableCopy];
+  NSMutableParagraphStyle *pStyle = [typingAttrs[NSParagraphStyleAttributeName] mutableCopy];
+  pStyle.textLists = @[];
+  pStyle.headIndent = 0;
+  pStyle.firstLineHeadIndent = 0;
+  typingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  _input->textView.typingAttributes = typingAttrs;
+}
+
+// needed for the sake of style conflicts, needs to do exactly the same as removeAttribtues
+- (void)removeTypingAttributes {
+  [self removeAttributes:_input->textView.selectedRange];
+}
+
+// removing first list point by backspacing doesn't remove typing attributes because it doesn't run textViewDidChange
+// so we try guessing that a point should be deleted here
+- (BOOL)handleBackspaceInRange:(NSRange)range replacementText:(NSString *)text {
+  if([self detectStyle:_input->textView.selectedRange] &&
+     NSEqualRanges(_input->textView.selectedRange, NSMakeRange(0, 0)) &&
+     [text isEqualToString:@""]
+  ) {
+    NSRange paragraphRange = [_input->textView.textStorage.string paragraphRangeForRange:_input->textView.selectedRange];
+    [self removeAttributes:paragraphRange];
+    return YES;
+  }
+  return NO;
+}
+
+- (BOOL)tryHandlingListShorcutInRange:(NSRange)range replacementText:(NSString *)text {
+  NSRange paragraphRange = [_input->textView.textStorage.string paragraphRangeForRange:range];
+  // space was added - check if we are both at the paragraph beginning + 1 character (which we want to be a dash)
+  if([text isEqualToString:@" "] && range.location - 1 == paragraphRange.location) {
+    unichar charBefore = [_input->textView.textStorage.string characterAtIndex:range.location - 1];
+    if(charBefore == '-') {
+      // we got a match - add a list if possible
+      if([_input handleStyleBlocksAndConflicts:[[self class] getStyleType] range:paragraphRange]) {
+        // don't emit some html updates during the replacing
+        BOOL prevEmitHtml = _input->emitHtml;
+        if(prevEmitHtml) {
+          _input->emitHtml = NO;
+        }
+        
+        // remove the dash
+        [TextInsertionUtils replaceText:@"" at:NSMakeRange(paragraphRange.location, 1) additionalAttributes:nullptr input:_input withSelection:YES];
+        
+        if(prevEmitHtml) {
+          _input->emitHtml = YES;
+        }
+        
+        // add attributes on the dashless paragraph
+        [self addAttributes:NSMakeRange(paragraphRange.location, paragraphRange.length - 1)];
+        return YES;
+      }
+    }
+  }
+  return NO;
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  NSParagraphStyle *paragraph = (NSParagraphStyle *)value;
+  return paragraph != nullptr && paragraph.textLists.count == 1 && paragraph.textLists.firstObject.markerFormat == NSTextListMarkerDisc;
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    return [OccurenceUtils detect:NSParagraphStyleAttributeName withInput:_input inRange:range
+      withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  } else {
+    NSInteger searchLocation = range.location;
+    if(searchLocation == _input->textView.textStorage.length) {
+      NSParagraphStyle *pStyle = _input->textView.typingAttributes[NSParagraphStyleAttributeName];
+      return [self styleCondition:pStyle :NSMakeRange(0, 0)];
+    }
+    
+    NSRange paragraphRange = NSMakeRange(0, 0);
+    NSRange inputRange = NSMakeRange(0, _input->textView.textStorage.length);
+    NSParagraphStyle *paragraph = [_input->textView.textStorage
+      attribute:NSParagraphStyleAttributeName
+      atIndex:searchLocation
+      longestEffectiveRange: &paragraphRange
+      inRange:inputRange
+    ];
+    
+    return [self styleCondition:paragraph :NSMakeRange(0, 0)];
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:NSParagraphStyleAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+- (NSArray<StylePair *> *_Nullable)findAllOccurences:(NSRange)range {
+  return [OccurenceUtils all:NSParagraphStyleAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+@end

package/ios/utils/BaseStyleProtocol.h

@@ -0,0 +1,16 @@
+#pragma once
+#import "StyleTypeEnum.h"
+#import "StylePair.h"
+
+@protocol BaseStyleProtocol <NSObject>
++ (StyleType)getStyleType;
+- (instancetype _Nonnull)initWithInput:(id _Nonnull)input;
+- (void)applyStyle:(NSRange)range;
+- (void)addAttributes:(NSRange)range;
+- (void)removeAttributes:(NSRange)range;
+- (void)addTypingAttributes;
+- (void)removeTypingAttributes;
+- (BOOL)detectStyle:(NSRange)range;
+- (BOOL)anyOccurence:(NSRange)range;
+- (NSArray<StylePair *> *_Nullable)findAllOccurences:(NSRange)range;
+@end

package/ios/utils/ColorExtension.h

@@ -0,0 +1,6 @@
+#import <UIKit/UIKit.h>
+#pragma once
+
+@interface UIColor (ColorExtension)
+- (BOOL)isEqualToColor:(UIColor *)otherColor;
+@end

package/ios/utils/ColorExtension.mm

@@ -0,0 +1,27 @@
+#import "ColorExtension.h"
+
+@implementation UIColor (ColorExtension)
+- (BOOL)isEqualToColor:(UIColor *)otherColor {
+  CGColorSpaceRef colorSpaceRGB = CGColorSpaceCreateDeviceRGB();
+
+  UIColor *(^convertColorToRGBSpace)(UIColor*) = ^(UIColor *color) {
+    if(CGColorSpaceGetModel(CGColorGetColorSpace(color.CGColor)) == kCGColorSpaceModelMonochrome) {
+      const CGFloat *oldComponents = CGColorGetComponents(color.CGColor);
+      CGFloat components[4] = {oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1]};
+      CGColorRef colorRef = CGColorCreate( colorSpaceRGB, components );
+
+      UIColor *color = [UIColor colorWithCGColor:colorRef];
+      CGColorRelease(colorRef);
+      return color;
+    } else {
+      return color;
+    }
+  };
+
+  UIColor *selfColor = convertColorToRGBSpace(self);
+  otherColor = convertColorToRGBSpace(otherColor);
+  CGColorSpaceRelease(colorSpaceRGB);
+
+  return [selfColor isEqual:otherColor];
+}
+@end

package/ios/utils/FontExtension.h

@@ -0,0 +1,13 @@
+#import <UIKit/UIKit.h>
+#pragma once
+
+@interface UIFont (FontExtension)
+- (BOOL)isBold;
+- (UIFont *)setBold;
+- (UIFont *)removeBold;
+- (BOOL)isItalic;
+- (UIFont *)setItalic;
+- (UIFont *)removeItalic;
+- (UIFont *)withFontTraits:(UIFont *)from;
+- (UIFont *)setSize:(CGFloat)size;
+@end

package/ios/utils/FontExtension.mm

@@ -0,0 +1,91 @@
+#import "FontExtension.h"
+#import <React/RCTLog.h>
+
+@implementation UIFont (FontExtension)
+
+- (BOOL)isBold {
+  return (self.fontDescriptor.symbolicTraits & UIFontDescriptorTraitBold) == UIFontDescriptorTraitBold;
+}
+
+- (UIFont *)setBold {
+  if([self isBold]) {
+    return self;
+  }
+  UIFontDescriptorSymbolicTraits newTraits = (self.fontDescriptor.symbolicTraits | UIFontDescriptorTraitBold);
+  UIFontDescriptor *fontDescriptor = [self.fontDescriptor fontDescriptorWithSymbolicTraits:newTraits];
+  if(fontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:fontDescriptor size:0];
+  } else {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't apply bold trait to the font.");
+    return self;
+  }
+}
+
+- (UIFont *)removeBold {
+  if(![self isBold]) {
+    return self;
+  }
+  UIFontDescriptorSymbolicTraits newTraits = (self.fontDescriptor.symbolicTraits ^ UIFontDescriptorTraitBold);
+  UIFontDescriptor *fontDescriptor = [self.fontDescriptor fontDescriptorWithSymbolicTraits:newTraits];
+  if(fontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:fontDescriptor size:0];
+  } else {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't remove bold trait from the font.");
+    return self;
+  }
+}
+
+- (BOOL)isItalic {
+  return (self.fontDescriptor.symbolicTraits & UIFontDescriptorTraitItalic) == UIFontDescriptorTraitItalic;
+}
+
+- (UIFont *)setItalic {
+  if([self isItalic]) {
+    return self;
+  }
+  UIFontDescriptorSymbolicTraits newTraits = (self.fontDescriptor.symbolicTraits | UIFontDescriptorTraitItalic);
+  UIFontDescriptor *fontDescriptor = [self.fontDescriptor fontDescriptorWithSymbolicTraits:newTraits];
+  if(fontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:fontDescriptor size:0];
+  } else {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't apply italic trait to the font.");
+    return self;
+  }
+}
+
+- (UIFont *)removeItalic {
+  if(![self isItalic]) {
+    return self;
+  }
+  UIFontDescriptorSymbolicTraits newTraits = (self.fontDescriptor.symbolicTraits ^ UIFontDescriptorTraitItalic);
+  UIFontDescriptor *fontDescriptor = [self.fontDescriptor fontDescriptorWithSymbolicTraits:newTraits];
+  if(fontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:fontDescriptor size:0];
+  } else {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't remove italic trait from the font.");
+    return self;
+  }
+}
+
+- (UIFont *)withFontTraits:(UIFont *)from {
+  UIFont* newFont = self;
+  if([from isBold]) {
+    newFont = [newFont setBold];
+  }
+  if([from isItalic]) {
+    newFont = [newFont setItalic];
+  }
+  return newFont;
+}
+
+- (UIFont *)setSize:(CGFloat)size {
+  UIFontDescriptor *newFontDescriptor = [self.fontDescriptor fontDescriptorWithSize:size];
+  if(newFontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:newFontDescriptor size:0];
+  } else {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't apply heading style to the font.");
+    return self;
+  }
+}
+
+@end

package/ios/utils/LayoutManagerExtension.h

@@ -0,0 +1,6 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface NSLayoutManager (LayoutManagerExtension)
+@property (nonatomic, weak) id input;
+@end