react-native-enriched 0.0.0 → 0.1.1

package/ios/styles/H3Style.mm

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

package/ios/styles/HeadingStyleBase.mm

@@ -0,0 +1,144 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "FontExtension.h"
+#import "OccurenceUtils.h"
+
+@implementation HeadingStyleBase
+
+// mock values since H1/2/3Style classes anyway are used
++ (StyleType)getStyleType { return None; }
+- (CGFloat)getHeadingFontSize { return 0; }
+- (BOOL)isHeadingBold { return false; }
+
+- (EnrichedTextInputView *)typedInput {
+  return (EnrichedTextInputView *)input;
+}
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  self->input = input;
+  return self;
+}
+
+// the range will already be the full paragraph/s range
+// but if the paragraph is empty it still is of length 0
+- (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];
+  }
+}
+
+// the range will already be the proper full paragraph/s range
+- (void)addAttributes:(NSRange)range {
+  [[self typedInput]->textView.textStorage beginEditing];
+  [[self typedInput]->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 setSize:[self getHeadingFontSize]];
+        if([self isHeadingBold]) {
+          newFont = [newFont setBold];
+        }
+        [[self typedInput]->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+      }
+    }
+  ];
+  [[self typedInput]->textView.textStorage endEditing];
+  
+  // also toggle typing attributes
+  [self addTypingAttributes];
+}
+
+// will always be called on empty paragraphs so only typing attributes can be changed
+- (void)addTypingAttributes {
+  UIFont *currentFontAttr = (UIFont *)[self typedInput]->textView.typingAttributes[NSFontAttributeName];
+  if(currentFontAttr != nullptr) {
+    NSMutableDictionary *newTypingAttrs = [[self typedInput]->textView.typingAttributes mutableCopy];
+    UIFont *newFont = [currentFontAttr setSize:[self getHeadingFontSize]];
+    if([self isHeadingBold]) {
+      newFont = [newFont setBold];
+    }
+    newTypingAttrs[NSFontAttributeName] = newFont;
+    [self typedInput]->textView.typingAttributes = newTypingAttrs;
+  }
+}
+
+// we need to remove the style from the whole paragraph
+- (void)removeAttributes:(NSRange)range {
+  NSRange paragraphRange = [[self typedInput]->textView.textStorage.string paragraphRangeForRange:range];
+  
+  [[self typedInput]->textView.textStorage beginEditing];
+  [[self typedInput]->textView.textStorage enumerateAttribute:NSFontAttributeName inRange:paragraphRange options:0
+    usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+      if([self styleCondition:value :range]) {
+        UIFont *newFont = [(UIFont *)value setSize:[[[self typedInput]->config primaryFontSize] floatValue]];
+        if([self isHeadingBold]) {
+          newFont = [newFont removeBold];
+        }
+        [[self typedInput]->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+      }
+    }
+  ];
+  [[self typedInput]->textView.textStorage endEditing];
+  
+  // typing attributes still need to be removed
+  UIFont *currentFontAttr = (UIFont *)[self typedInput]->textView.typingAttributes[NSFontAttributeName];
+  if(currentFontAttr != nullptr) {
+    NSMutableDictionary *newTypingAttrs = [[self typedInput]->textView.typingAttributes mutableCopy];
+    UIFont *newFont = [currentFontAttr setSize:[[[self typedInput]->config primaryFontSize] floatValue]];
+    if([self isHeadingBold]) {
+      newFont = [newFont removeBold];
+    }
+    newTypingAttrs[NSFontAttributeName] = newFont;
+    [self typedInput]->textView.typingAttributes = newTypingAttrs;
+  }
+}
+
+- (void)removeTypingAttributes {
+  // all the heading still needs to be removed because this function may be called in conflicting styles logic
+  // typing attributes already get removed in there as well
+  [self removeAttributes:[self typedInput]->textView.selectedRange];
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  UIFont *font = (UIFont *)value;
+  return font != nullptr && font.pointSize == [self getHeadingFontSize];
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    return [OccurenceUtils detect:NSFontAttributeName withInput:[self typedInput] inRange:range
+      withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  } else {
+    UIFont *currentFontAttr = (UIFont *)[self typedInput]->textView.typingAttributes[NSFontAttributeName];
+    if(currentFontAttr == nullptr) {
+      return false;
+    }
+    return currentFontAttr.pointSize == [self getHeadingFontSize];
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:NSFontAttributeName withInput:[self typedInput] 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:[self typedInput] inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+@end
+

package/ios/styles/InlineCodeStyle.mm

@@ -0,0 +1,163 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "FontExtension.h"
+#import "OccurenceUtils.h"
+#import "ParagraphsUtils.h"
+
+@implementation InlineCodeStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return InlineCode; }
+
+- (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 {
+  // we don't want to apply inline code to newline characters, it looks bad
+  NSArray *nonNewlineRanges = [ParagraphsUtils getNonNewlineRangesIn:_input->textView range:range];
+  
+  for(NSValue *value in nonNewlineRanges) {
+    NSRange currentRange = [value rangeValue];
+    [_input->textView.textStorage beginEditing];
+
+    [_input->textView.textStorage addAttribute:NSBackgroundColorAttributeName value:[[_input->config inlineCodeBgColor] colorWithAlphaComponent:0.4] range:currentRange];
+    [_input->textView.textStorage addAttribute:NSForegroundColorAttributeName value:[_input->config inlineCodeFgColor] range:currentRange];
+    [_input->textView.textStorage addAttribute:NSUnderlineColorAttributeName value:[_input->config inlineCodeFgColor] range:currentRange];
+    [_input->textView.textStorage addAttribute:NSStrikethroughColorAttributeName value:[_input->config inlineCodeFgColor] range:currentRange];
+    [_input->textView.textStorage enumerateAttribute:NSFontAttributeName inRange:currentRange options:0
+      usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+        UIFont *font = (UIFont *)value;
+        if(font != nullptr) {
+          UIFont *newFont = [[_input->config monospacedFont] withFontTraits:font];
+          [_input->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+        }
+      }
+    ];
+    
+    [_input->textView.textStorage endEditing];
+  }
+}
+
+- (void)addTypingAttributes {
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  newTypingAttrs[NSBackgroundColorAttributeName] = [[_input->config inlineCodeBgColor] colorWithAlphaComponent:0.4];
+  newTypingAttrs[NSForegroundColorAttributeName] = [_input->config inlineCodeFgColor];
+  newTypingAttrs[NSUnderlineColorAttributeName] = [_input->config inlineCodeFgColor];
+  newTypingAttrs[NSStrikethroughColorAttributeName] = [_input->config inlineCodeFgColor];
+  UIFont* currentFont = (UIFont *)newTypingAttrs[NSFontAttributeName];
+  if(currentFont != nullptr) {
+    newTypingAttrs[NSFontAttributeName] = [[_input->config monospacedFont] withFontTraits:currentFont];
+  }
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (void)removeAttributes:(NSRange)range {
+  [_input->textView.textStorage beginEditing];
+
+  [_input->textView.textStorage removeAttribute:NSBackgroundColorAttributeName range:range];
+  [_input->textView.textStorage addAttribute:NSForegroundColorAttributeName value:[_input->config primaryColor] range:range];
+  [_input->textView.textStorage addAttribute:NSUnderlineColorAttributeName value:[_input->config primaryColor] range:range];
+  [_input->textView.textStorage addAttribute:NSStrikethroughColorAttributeName value:[_input->config primaryColor] range:range];
+  [_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 = [[_input->config primaryFont] withFontTraits:font];
+        [_input->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+      }
+    }
+  ];
+  
+  [_input->textView.textStorage endEditing];
+}
+
+- (void)removeTypingAttributes {
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  [newTypingAttrs removeObjectForKey:NSBackgroundColorAttributeName];
+  newTypingAttrs[NSForegroundColorAttributeName] = [_input->config primaryColor];
+  newTypingAttrs[NSUnderlineColorAttributeName] = [_input->config primaryColor];
+  newTypingAttrs[NSStrikethroughColorAttributeName] = [_input->config primaryColor];
+  UIFont* currentFont = (UIFont *)newTypingAttrs[NSFontAttributeName];
+  if(currentFont != nullptr) {
+    newTypingAttrs[NSFontAttributeName] = [[_input->config primaryFont] withFontTraits:currentFont];
+  }
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+// making sure no newlines get inline code style, it looks bad
+- (void)handleNewlines {
+  for(int i = 0; i < _input->textView.textStorage.string.length; i++) {
+    if([[NSCharacterSet newlineCharacterSet] characterIsMember:[_input->textView.textStorage.string characterAtIndex:i]]) {
+      NSRange mockRange = NSMakeRange(0, 0);
+      // can't use detect style because it intentionally doesn't take newlines into consideration
+      UIColor *bgColor = [_input->textView.textStorage attribute:NSBackgroundColorAttributeName atIndex:i effectiveRange:&mockRange];
+      if([self styleCondition:bgColor :NSMakeRange(i, 1)]) {
+        [self removeAttributes:NSMakeRange(i, 1)];
+      }
+    }
+  }
+}
+
+// emojis don't retain monospace font attribute so we check for the background color if there is no mention
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  UIColor *bgColor = (UIColor *)value;
+  MentionStyle *mStyle = _input->stylesDict[@([MentionStyle getStyleType])];
+  return bgColor != nullptr && mStyle != nullptr && ![mStyle detectStyle:range];
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    // detect only in non-newline characters
+    NSArray *nonNewlineRanges = [ParagraphsUtils getNonNewlineRangesIn:_input->textView range:range];
+    if(nonNewlineRanges.count == 0) {
+      return NO;
+    }
+    
+    BOOL detected = YES;
+    for(NSValue *value in nonNewlineRanges) {
+      NSRange currentRange = [value rangeValue];
+      BOOL currentDetected = [OccurenceUtils detect:NSBackgroundColorAttributeName withInput:_input inRange:currentRange
+        withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+          return [self styleCondition:value :range];
+        }
+      ];
+      detected = detected && currentDetected;
+    }
+  
+    return detected;
+  } else {
+    UIColor *currentBgColorAttr = (UIColor *)_input->textView.typingAttributes[NSBackgroundColorAttributeName];
+    return [self styleCondition:currentBgColorAttr :range];
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:NSBackgroundColorAttributeName 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:NSBackgroundColorAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+@end

package/ios/styles/ItalicStyle.mm

@@ -0,0 +1,110 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "FontExtension.h"
+#import "OccurenceUtils.h"
+
+@implementation ItalicStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return Italic; }
+
+- (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 setItalic];
+        [_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 setItalic];
+    _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 removeItalic];
+        [_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 removeItalic];
+    _input->textView.typingAttributes = newTypingAttrs;
+  }
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  UIFont *font = (UIFont *)value;
+  return font != nullptr && [font isItalic];
+}
+
+- (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];
+    if(currentFontAttr == nullptr) {
+      return false;
+    }
+    return [currentFontAttr isItalic];
+  }
+}
+
+- (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