react-native-enriched 0.0.0 → 0.1.1

package/ios/inputTextView/InputTextView.mm

@@ -0,0 +1,115 @@
+#import "InputTextView.h"
+#import "EnrichedTextInputView.h"
+#import "StringExtension.h"
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+#import "TextInsertionUtils.h"
+
+@implementation InputTextView
+
+- (void)copy:(id)sender {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)_input;
+  if(typedInput == nullptr) { return; }
+  
+  // remove zero width spaces before copying the text
+  NSString *plainText = [typedInput->textView.textStorage.string substringWithRange:typedInput->textView.selectedRange];
+  NSString *fixedPlainText = [plainText stringByReplacingOccurrencesOfString:@"\u200B" withString:@""];
+  
+  NSString *escapedHtml = [NSString stringByEscapingHtml:[typedInput->parser parseToHtmlFromRange:typedInput->textView.selectedRange]];
+  
+  NSMutableAttributedString *attrStr = [[typedInput->textView.textStorage attributedSubstringFromRange:typedInput->textView.selectedRange] mutableCopy];
+  NSRange fullAttrStrRange = NSMakeRange(0, attrStr.length);
+  [attrStr.mutableString replaceOccurrencesOfString:@"\u200B" withString:@"" options:0 range:fullAttrStrRange];
+  
+  NSData *rtfData = [attrStr dataFromRange:NSMakeRange(0, attrStr.length)
+    documentAttributes:@{NSDocumentTypeDocumentAttribute:NSRTFTextDocumentType}
+    error:nullptr
+  ];
+  
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  [pasteboard setItems:@[@{
+    UTTypeUTF8PlainText.identifier : fixedPlainText,
+    UTTypeHTML.identifier : escapedHtml,
+    UTTypeRTF.identifier : rtfData
+  }]];
+}
+
+- (void)paste:(id)sender {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)_input;
+  if(typedInput == nullptr) { return; }
+
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  NSArray<NSString *> *pasteboardTypes = pasteboard.pasteboardTypes;
+  NSRange currentRange = typedInput->textView.selectedRange;
+  
+  if([pasteboardTypes containsObject:UTTypeHTML.identifier]) {
+    // we try processing the html contents
+    
+    NSString *htmlString;
+    id htmlValue = [pasteboard valueForPasteboardType:UTTypeHTML.identifier];
+    
+    if([htmlValue isKindOfClass:[NSData class]]) {
+      htmlString = [[NSString alloc]initWithData:htmlValue encoding:NSUTF8StringEncoding];
+    } else if([htmlValue isKindOfClass:[NSString class]]) {
+      htmlString = htmlValue;
+    }
+    
+    // unescape the html
+    htmlString = [NSString stringByUnescapingHtml:htmlString];
+    // validate it
+    NSString *initiallyProcessedHtml = [typedInput->parser initiallyProcessHtml:htmlString];
+    
+    if(initiallyProcessedHtml != nullptr) {
+      // valid html, let's apply it
+      currentRange.length > 0
+        ? [typedInput->parser replaceFromHtml:initiallyProcessedHtml range:currentRange]
+        : [typedInput->parser insertFromHtml:initiallyProcessedHtml location:currentRange.location];
+    } else {
+      // fall back to plain text, otherwise do nothing
+      [self tryHandlingPlainTextItemsIn:pasteboard range:currentRange input:typedInput];
+    }
+  } else {
+    [self tryHandlingPlainTextItemsIn:pasteboard range:currentRange input:typedInput];
+  }
+  
+  [typedInput anyTextMayHaveBeenModified];
+}
+
+- (void)tryHandlingPlainTextItemsIn:(UIPasteboard *)pasteboard range:(NSRange)range input:(EnrichedTextInputView *)input {
+  NSArray *existingTypes = pasteboard.pasteboardTypes;
+  NSArray *handledTypes = @[UTTypeUTF8PlainText.identifier, UTTypePlainText.identifier];
+  NSString *plainText;
+  
+  for(NSString *type in handledTypes) {
+    if(![existingTypes containsObject:type]) {
+      continue;
+    }
+    
+    id value = [pasteboard valueForPasteboardType:type];
+    
+    if([value isKindOfClass:[NSData class]]) {
+      plainText = [[NSString alloc]initWithData:value encoding:NSUTF8StringEncoding];
+    } else if([value isKindOfClass:[NSString class]]) {
+      plainText = (NSString *)value;
+    }
+  }
+  
+  if(!plainText) {
+    return;
+  }
+  
+  range.length > 0
+    ? [TextInsertionUtils replaceText:plainText at:range additionalAttributes:nullptr input:input withSelection:YES]
+    : [TextInsertionUtils insertText:plainText at:range.location additionalAttributes:nullptr input:input withSelection:YES];
+}
+
+- (void)cut:(id)sender {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)_input;
+  if(typedInput == nullptr) { return; }
+  
+  [self copy:sender];
+  [TextInsertionUtils replaceText:@"" at:typedInput->textView.selectedRange additionalAttributes:nullptr input:typedInput  withSelection:YES];
+  
+  [typedInput anyTextMayHaveBeenModified];
+}
+
+@end

package/ios/internals/EnrichedTextInputViewComponentDescriptor.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <react/debug/react_native_assert.h>
+#include <ReactNativeEnriched/Props.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <ReactNativeEnriched/EnrichedTextInputViewShadowNode.h>
+
+namespace facebook::react {
+class EnrichedTextInputViewComponentDescriptor final : public ConcreteComponentDescriptor<EnrichedTextInputViewShadowNode> {
+  public:
+    using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+    void adopt(ShadowNode &shadowNode) const override {
+      react_native_assert(dynamic_cast<EnrichedTextInputViewShadowNode *>(&shadowNode));
+      ConcreteComponentDescriptor::adopt(shadowNode);
+    }
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewShadowNode.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <ReactNativeEnriched/EventEmitters.h>
+#include <ReactNativeEnriched/Props.h>
+#include <ReactNativeEnriched/EnrichedTextInputViewState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedTextInputViewComponentName[];
+
+/*
+ * `ShadowNode` for <EnrichedTextInputView> component.
+ */
+class EnrichedTextInputViewShadowNode : public ConcreteViewShadowNode<
+        EnrichedTextInputViewComponentName,
+        EnrichedTextInputViewProps,
+        EnrichedTextInputViewEventEmitter,
+        EnrichedTextInputViewState> {
+    public:
+    using ConcreteViewShadowNode::ConcreteViewShadowNode;
+    EnrichedTextInputViewShadowNode(const ShadowNodeFragment& fragment, const ShadowNodeFamily::Shared& family, ShadowNodeTraits traits);
+    EnrichedTextInputViewShadowNode(const ShadowNode& sourceShadowNode, const ShadowNodeFragment& fragment);
+    void dirtyLayoutIfNeeded();
+    Size measureContent(const LayoutContext& layoutContext, const LayoutConstraints& layoutConstraints) const override;
+    
+    
+    static ShadowNodeTraits BaseTraits() {
+      auto traits = ConcreteViewShadowNode::BaseTraits();
+      traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+      traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+      return traits;
+    }
+    
+    private:
+    int localForceHeightRecalculationCounter_;
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewShadowNode.mm

@@ -0,0 +1,83 @@
+#import "EnrichedTextInputViewShadowNode.h"
+#import <EnrichedTextInputView.h>
+#import <react/utils/ManagedObjectWrapper.h>
+#import <yoga/Yoga.h>
+#import <React/RCTShadowView+Layout.h>
+#import "CoreText/CoreText.h"
+
+namespace facebook::react {
+
+extern const char EnrichedTextInputViewComponentName[] = "EnrichedTextInputView";
+
+EnrichedTextInputViewShadowNode::EnrichedTextInputViewShadowNode(
+  const ShadowNodeFragment& fragment,
+  const ShadowNodeFamily::Shared& family,
+  ShadowNodeTraits traits
+): ConcreteViewShadowNode(fragment, family, traits) {
+  localForceHeightRecalculationCounter_ = 0;
+}
+
+EnrichedTextInputViewShadowNode::EnrichedTextInputViewShadowNode(
+  const ShadowNode& sourceShadowNode,
+  const ShadowNodeFragment& fragment
+): ConcreteViewShadowNode(sourceShadowNode, fragment) {
+  dirtyLayoutIfNeeded();
+}
+
+void EnrichedTextInputViewShadowNode::dirtyLayoutIfNeeded() {
+  const auto state = this->getStateData();
+  const int receivedCounter = state.getForceHeightRecalculationCounter();
+  
+  if(receivedCounter > localForceHeightRecalculationCounter_) {
+    localForceHeightRecalculationCounter_ = receivedCounter;
+    YGNodeMarkDirty(&yogaNode_);
+  }
+}
+
+Size EnrichedTextInputViewShadowNode::measureContent(const LayoutContext& layoutContext, const LayoutConstraints& layoutConstraints) const {
+  const auto state = this->getStateData();
+  const auto componentRef = state.getComponentViewRef();
+  RCTInternalGenericWeakWrapper *weakWrapper = (RCTInternalGenericWeakWrapper *)unwrapManagedObject(componentRef);
+  
+  if(weakWrapper != nullptr) {
+    id componentObject = weakWrapper.object;
+    EnrichedTextInputView *typedComponentObject = (EnrichedTextInputView *) componentObject;
+    
+    if(typedComponentObject != nullptr) {
+      __block CGSize estimatedSize;
+      
+      // synchronously dispatch to main thread if needed
+      if([NSThread isMainThread]) {
+        estimatedSize = [typedComponentObject measureSize:layoutConstraints.maximumSize.width];
+      } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+          estimatedSize = [typedComponentObject measureSize:layoutConstraints.maximumSize.width];
+        });
+      }
+      
+      return {estimatedSize.width, estimatedSize.height};
+    }
+  } else {
+    // on the very first call there is no componentView that we can query for the component height
+    // thus, a little heuristic: just put a height that is exactly height of letter "I" with default apple font and size from props
+    // in a lot of cases it will be the desired height
+    // in others, the jump on the second call will at least be smaller
+    const auto props = this->getProps();
+    const auto &typedProps = *std::static_pointer_cast<EnrichedTextInputViewProps const>(props);
+    NSAttributedString *attrStr = [[NSAttributedString alloc] initWithString:@"I" attributes:@{NSFontAttributeName: [UIFont systemFontOfSize:typedProps.fontSize]}];
+    CTFramesetterRef framesetter = CTFramesetterCreateWithAttributedString((CFAttributedStringRef)attrStr);
+    const CGSize &suggestedSize = CTFramesetterSuggestFrameSizeWithConstraints(
+      framesetter,
+      CFRangeMake(0, 1),
+      nullptr,
+      CGSizeMake(layoutConstraints.maximumSize.width, DBL_MAX),
+      nullptr
+    );
+    
+    return {suggestedSize.width, suggestedSize.height};
+  }
+  
+  return Size();
+}
+ 
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewState.cpp

@@ -0,0 +1,10 @@
+#include "EnrichedTextInputViewState.h"
+
+namespace facebook::react {
+    int EnrichedTextInputViewState::getForceHeightRecalculationCounter() const {
+      return forceHeightRecalculationCounter_;
+    }
+    std::shared_ptr<void> EnrichedTextInputViewState::getComponentViewRef() const {
+      return componentViewRef_;
+    }
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewState.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <memory>
+
+namespace facebook::react {
+
+class EnrichedTextInputViewState {
+public:
+  EnrichedTextInputViewState(): forceHeightRecalculationCounter_(0), componentViewRef_(nullptr) {}
+  EnrichedTextInputViewState(int counter, std::shared_ptr<void> ref) {
+    forceHeightRecalculationCounter_ = counter;
+    componentViewRef_ = ref;
+  }
+  int getForceHeightRecalculationCounter() const;
+  std::shared_ptr<void> getComponentViewRef() const;
+private:
+  int forceHeightRecalculationCounter_{};
+  std::shared_ptr<void> componentViewRef_{};
+};
+
+} // namespace facebook::react

package/ios/styles/BlockQuoteStyle.mm

@@ -0,0 +1,248 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "OccurenceUtils.h"
+#import "ParagraphsUtils.h"
+#import "TextInsertionUtils.h"
+#import "ColorExtension.h"
+
+@implementation BlockQuoteStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return BlockQuote; }
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  return self;
+}
+
+- (CGFloat)getHeadIndent {
+  // rectangle width + gap
+  return [_input->config blockquoteBorderWidth] + [_input->config blockquoteGapWidth];
+}
+
+// the range will already be the full paragraph/s range
+- (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 {
+  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;
+  NSRange preModificationRange = _input->textView.selectedRange;
+  
+  // to not emit any space filling selection/text changes
+  _input->blockEmitting = YES;
+  
+  for(NSValue *value in paragraphs) {
+    NSRange pRange = 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(pRange.length == 0 ||
+      (pRange.length == 1 &&
+      [[NSCharacterSet newlineCharacterSet] characterIsMember: [_input->textView.textStorage.string characterAtIndex:pRange.location]])
+    ) {
+      [TextInsertionUtils insertText:@"\u200B" at:pRange.location additionalAttributes:nullptr input:_input withSelection:NO];
+      pRange = NSMakeRange(pRange.location, pRange.length + 1);
+      offset += 1;
+    }
+    
+    [_input->textView.textStorage enumerateAttribute:NSParagraphStyleAttributeName inRange:pRange options:0
+      usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+        NSMutableParagraphStyle *pStyle = [(NSParagraphStyle *)value mutableCopy];
+        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.headIndent = [self getHeadIndent];
+  pStyle.firstLineHeadIndent = [self getHeadIndent];
+  typingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  _input->textView.typingAttributes = typingAttrs;
+}
+
+// does pretty much the same as addAttributes
+- (void)addTypingAttributes {
+  [self addAttributes:_input->textView.selectedRange];
+}
+
+- (void)removeAttributes:(NSRange)range {
+  NSArray *paragraphs = [ParagraphsUtils getSeparateParagraphsRangesIn:_input->textView range:range];
+  
+  for(NSValue *value in paragraphs) {
+    NSRange pRange = [value rangeValue];
+    [_input->textView.textStorage enumerateAttribute:NSParagraphStyleAttributeName inRange:pRange options:0
+      usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+        NSMutableParagraphStyle *pStyle = [(NSParagraphStyle *)value mutableCopy];
+        pStyle.headIndent = 0;
+        pStyle.firstLineHeadIndent = 0;
+        [_input->textView.textStorage addAttribute:NSParagraphStyleAttributeName value:pStyle range:range];
+      }
+    ];
+  }
+  
+  // also remove typing attributes
+  NSMutableDictionary *typingAttrs = [_input->textView.typingAttributes mutableCopy];
+  NSMutableParagraphStyle *pStyle = [typingAttrs[NSParagraphStyleAttributeName] mutableCopy];
+  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 quote line 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)styleCondition:(id _Nullable)value :(NSRange)range {
+  NSParagraphStyle *pStyle = (NSParagraphStyle *)value;
+  return pStyle != nullptr && pStyle.headIndent == [self getHeadIndent] && pStyle.firstLineHeadIndent == [self getHeadIndent] && pStyle.textLists.count == 0;
+}
+
+- (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];
+    }
+  ];
+}
+
+// gets ranges that aren't link, mention or inline code
+- (NSArray *)getProperColorRangesIn:(NSRange)range {
+  LinkStyle *linkStyle = _input->stylesDict[@([LinkStyle getStyleType])];
+  MentionStyle *mentionStyle = _input->stylesDict[@([MentionStyle getStyleType])];
+  InlineCodeStyle *codeStyle = _input->stylesDict[@([InlineCodeStyle getStyleType])];
+  
+  NSMutableArray *newRanges = [[NSMutableArray alloc] init];
+  int lastRangeLocation = range.location;
+  
+  for(int i = range.location; i < range.location + range.length; i++) {
+    NSRange currentRange = NSMakeRange(i, 1);
+    if([linkStyle detectStyle:currentRange] || [mentionStyle detectStyle:currentRange] || [codeStyle detectStyle:currentRange]) {
+      if(i - lastRangeLocation > 0) {
+        [newRanges addObject:[NSValue valueWithRange:NSMakeRange(lastRangeLocation, i - lastRangeLocation)]];
+      }
+      lastRangeLocation = i+1;
+    }
+  }
+  if(lastRangeLocation < range.location + range.length) {
+    [newRanges addObject:[NSValue valueWithRange:NSMakeRange(lastRangeLocation, range.location + range.length - lastRangeLocation)]];
+  }
+  
+  return newRanges;
+}
+
+// general checkup correcting blockquote color
+// since links, mentions and inline code affects coloring, the checkup gets done only outside of them
+- (void)manageBlockquoteColor {
+  if([[_input->config blockquoteColor] isEqualToColor:[_input->config primaryColor]]) {
+    return;
+  }
+  
+  NSRange wholeRange = NSMakeRange(0, _input->textView.textStorage.string.length);
+  
+  NSArray *paragraphs = [ParagraphsUtils getSeparateParagraphsRangesIn:_input->textView range:wholeRange];
+  for(NSValue *pValue in paragraphs) {
+    NSRange paragraphRange = [pValue rangeValue];
+    NSArray *properRanges = [self getProperColorRangesIn:paragraphRange];
+    
+    for(NSValue *value in properRanges) {
+      NSRange currRange = [value rangeValue];
+      BOOL selfDetected = [self detectStyle:currRange];
+      
+      [_input->textView.textStorage enumerateAttribute:NSForegroundColorAttributeName inRange:currRange options:0
+        usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+          UIColor *newColor = nullptr;
+          BOOL colorApplied = [(UIColor *)value isEqualToColor:[_input->config blockquoteColor]];
+          
+          if(colorApplied && !selfDetected) {
+            newColor = [_input->config primaryColor];
+          } else if(!colorApplied && selfDetected) {
+            newColor = [_input->config blockquoteColor];
+          }
+      
+          if(newColor != nullptr) {
+            [_input->textView.textStorage addAttribute:NSForegroundColorAttributeName value:newColor range:currRange];
+            [_input->textView.textStorage addAttribute:NSUnderlineColorAttributeName value:newColor range:currRange];
+            [_input->textView.textStorage addAttribute:NSStrikethroughColorAttributeName value:newColor range:currRange];
+          }
+        }
+      ];
+    }
+  }
+}
+
+@end

package/ios/styles/BoldStyle.mm

@@ -0,0 +1,122 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "FontExtension.h"
+#import "OccurenceUtils.h"
+
+@implementation BoldStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return Bold; }
+
+- (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 beginEditing];
+  [_input->textView.textStorage enumerateAttribute:NSFontAttributeName inRange:range options:0
+    usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+      UIFont *font = (UIFont *)value;
+      if(font != nullptr) {
+        UIFont *newFont = [font setBold];
+        [_input->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+      }
+    }
+  ];
+  [_input->textView.textStorage endEditing];
+}
+
+- (void)addTypingAttributes {
+  UIFont *currentFontAttr = (UIFont *)_input->textView.typingAttributes[NSFontAttributeName];
+  if(currentFontAttr != nullptr) {
+    NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+    newTypingAttrs[NSFontAttributeName] = [currentFontAttr setBold];
+    _input->textView.typingAttributes = newTypingAttrs;
+  }
+}
+
+- (void)removeAttributes:(NSRange)range {
+  [_input->textView.textStorage beginEditing];
+  [_input->textView.textStorage enumerateAttribute:NSFontAttributeName inRange:range options:0
+    usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+      UIFont *font = (UIFont *)value;
+      if(font != nullptr) {
+        UIFont *newFont = [font removeBold];
+        [_input->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+      }
+    }
+  ];
+  [_input->textView.textStorage endEditing];
+}
+
+- (void)removeTypingAttributes {
+  UIFont *currentFontAttr = (UIFont *)_input->textView.typingAttributes[NSFontAttributeName];
+  if(currentFontAttr != nullptr) {
+    NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+    newTypingAttrs[NSFontAttributeName] = [currentFontAttr removeBold];
+    _input->textView.typingAttributes = newTypingAttrs;
+  }
+}
+
+- (BOOL)boldHeadingConflictsInRange:(NSRange)range type:(StyleType)type {
+  if(type == H1) {
+    if(![_input->config h1Bold]) { return NO; }
+  } else if(type == H2) {
+    if(![_input->config h2Bold]) { return NO; }
+  } else if(type == H3) {
+    if(![_input->config h3Bold]) { return NO; }
+  }
+  
+  id<BaseStyleProtocol> headingStyle = _input->stylesDict[@(type)];
+  return range.length > 0
+    ? [headingStyle anyOccurence:range]
+    : [headingStyle detectStyle:range];
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  UIFont *font = (UIFont *)value;
+  return font != nullptr && [font isBold] && ![self boldHeadingConflictsInRange:range type:H1] && ![self boldHeadingConflictsInRange:range type:H2] && ![self boldHeadingConflictsInRange:range type:H3];
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    return [OccurenceUtils detect:NSFontAttributeName withInput:_input inRange:range
+      withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  } else {
+    UIFont *currentFontAttr = (UIFont *)_input->textView.typingAttributes[NSFontAttributeName];
+    return [self styleCondition:currentFontAttr :range];
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:NSFontAttributeName 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:NSFontAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+@end

package/ios/styles/H1Style.mm

@@ -0,0 +1,10 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+
+@implementation H1Style
++ (StyleType)getStyleType { return H1; }
+- (CGFloat)getHeadingFontSize { return [((EnrichedTextInputView *)input)->config h1FontSize]; }
+- (BOOL)isHeadingBold {
+  return [((EnrichedTextInputView *)input)->config h1Bold];
+}
+@end

package/ios/styles/H2Style.mm

@@ -0,0 +1,10 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+
+@implementation H2Style
++ (StyleType)getStyleType { return H2; }
+- (CGFloat)getHeadingFontSize { return [((EnrichedTextInputView *)input)->config h2FontSize]; }
+- (BOOL)isHeadingBold {
+  return [((EnrichedTextInputView *)input)->config h2Bold];
+}
+@end