react-native-enriched 0.1.6 → 0.2.0

package/ios/styles/CodeBlockStyle.mm

@@ -0,0 +1,228 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "FontExtension.h"
+#import "OccurenceUtils.h"
+#import "ParagraphsUtils.h"
+#import "TextInsertionUtils.h"
+#import "ColorExtension.h"
+
+@implementation CodeBlockStyle {
+  EnrichedTextInputView *_input;
+  NSArray *_stylesToExclude;
+}
+
++ (StyleType)getStyleType { return CodeBlock; }
+
++ (BOOL)isParagraphStyle { return YES; }
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  _stylesToExclude = @[ @(InlineCode), @(Mention), @(Link) ];
+  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 {
+  NSTextList *codeBlockList = [[NSTextList alloc] initWithMarkerFormat:@"codeblock" 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;
+  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.textLists = @[codeBlockList];
+        [_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 = @[codeBlockList];
+  typingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  
+  _input->textView.typingAttributes = typingAttrs;
+}
+
+- (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 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.textLists = @[];
+        [_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 = @[];
+  
+  typingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  
+  _input->textView.typingAttributes = typingAttrs;
+}
+
+- (void)removeTypingAttributes {
+  [self removeAttributes:_input->textView.selectedRange];
+}
+
+- (BOOL)handleBackspaceInRange:(NSRange)range replacementText:(NSString *)text {
+  if([self detectStyle:_input->textView.selectedRange] && text.length == 0) {
+    // backspace while the style is active
+    
+    NSRange paragraphRange = [_input->textView.textStorage.string paragraphRangeForRange:_input->textView.selectedRange];
+    
+    if(NSEqualRanges(_input->textView.selectedRange, NSMakeRange(0, 0))) {
+      // a backspace on the very first input's line quote
+      // it doesn't run textVieDidChange so we need to manually remove attributes
+      [self removeAttributes:paragraphRange];
+      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 isEqualToString:@"codeblock"];
+}
+
+- (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 {
+    return [OccurenceUtils detect:NSParagraphStyleAttributeName withInput:_input atIndex:range.location checkPrevious:YES
+      withCondition:^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  }
+}
+
+- (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];
+    }
+  ];
+}
+
+- (void)manageCodeBlockFontAndColor {
+  if([[_input->config codeBlockFgColor] 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 = [OccurenceUtils getRangesWithout:_stylesToExclude withInput:_input inRange:paragraphRange];
+    
+    for(NSValue *value in properRanges) {
+      NSRange currRange = [value rangeValue];
+      BOOL selfDetected = [self detectStyle:currRange];
+      
+      [_input->textView.textStorage enumerateAttribute:NSFontAttributeName inRange:currRange options:0
+                                            usingBlock:^(id  _Nullable value, NSRange range, BOOL * _Nonnull stop) {
+        UIFont *currentFont = (UIFont *)value;
+        UIFont *newFont = nullptr;
+        
+        BOOL isCodeFont = [[currentFont familyName] isEqualToString:[[_input->config monospacedFont] familyName]];
+        
+        if (isCodeFont && !selfDetected) {
+          newFont = [[[_input->config primaryFont] withFontTraits:currentFont] setSize:currentFont.pointSize];
+        } else if (!isCodeFont && selfDetected) {
+          newFont = [[[_input->config monospacedFont] withFontTraits:currentFont] setSize:currentFont.pointSize];
+        }
+        
+        if (newFont != nullptr) {
+          [_input->textView.textStorage addAttribute:NSFontAttributeName value:newFont range:range];
+        }
+      }];
+      
+      [_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 codeBlockFgColor]];
+
+        if(colorApplied && !selfDetected) {
+          newColor = [_input->config primaryColor];
+        } else if(!colorApplied && selfDetected) {
+          newColor = [_input->config codeBlockFgColor];
+        }
+
+        if(newColor != nullptr) {
+          [_input->textView.textStorage addAttribute:NSForegroundColorAttributeName value:newColor range:range];
+        }
+      }];
+    }
+  }
+}
+
+@end

package/ios/styles/H1Style.mm

@@ -3,6 +3,7 @@
 
 @implementation H1Style
 + (StyleType)getStyleType { return H1; }
++ (BOOL)isParagraphStyle { return YES; }
 - (CGFloat)getHeadingFontSize { return [((EnrichedTextInputView *)input)->config h1FontSize]; }
 - (BOOL)isHeadingBold {
   return [((EnrichedTextInputView *)input)->config h1Bold];

package/ios/styles/H2Style.mm

@@ -3,6 +3,7 @@
 
 @implementation H2Style
 + (StyleType)getStyleType { return H2; }
++ (BOOL)isParagraphStyle { return YES; }
 - (CGFloat)getHeadingFontSize { return [((EnrichedTextInputView *)input)->config h2FontSize]; }
 - (BOOL)isHeadingBold {
   return [((EnrichedTextInputView *)input)->config h2Bold];

package/ios/styles/H3Style.mm

@@ -3,6 +3,7 @@
 
 @implementation H3Style
 + (StyleType)getStyleType { return H3; }
++ (BOOL)isParagraphStyle { return YES; }
 - (CGFloat)getHeadingFontSize { return [((EnrichedTextInputView *)input)->config h3FontSize]; }
 - (BOOL)isHeadingBold {
   return [((EnrichedTextInputView *)input)->config h3Bold];

package/ios/styles/ImageStyle.mm

@@ -0,0 +1,158 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "OccurenceUtils.h"
+#import "TextInsertionUtils.h"
+
+// custom NSAttributedStringKey to differentiate the image
+static NSString *const ImageAttributeName = @"ImageAttributeName";
+
+@implementation ImageStyle {
+  EnrichedTextInputView *_input;
+}
+
++ (StyleType)getStyleType { return Image; }
+
++ (BOOL)isParagraphStyle { return NO; }
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  return self;
+}
+
+- (void)applyStyle:(NSRange)range {
+  // no-op for image
+}
+
+- (void)addAttributes:(NSRange)range {
+  // no-op for image
+}
+
+- (void)addTypingAttributes {
+  // no-op for image
+}
+
+- (void)removeAttributes:(NSRange)range {
+  [_input->textView.textStorage beginEditing];
+  [_input->textView.textStorage removeAttribute:ImageAttributeName range:range];
+  [_input->textView.textStorage removeAttribute:NSAttachmentAttributeName range:range];
+  [_input->textView.textStorage endEditing];
+}
+
+- (void)removeTypingAttributes {
+  NSMutableDictionary *currentAttributes = [_input->textView.typingAttributes mutableCopy];
+  [currentAttributes removeObjectForKey:ImageAttributeName];
+  [currentAttributes removeObjectForKey:NSAttachmentAttributeName];
+  _input->textView.typingAttributes = currentAttributes;
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  return [value isKindOfClass:[ImageData class]];
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:ImageAttributeName withInput:_input inRange:range
+      withCondition:^BOOL(id  _Nullable value, NSRange range) {
+          return [self styleCondition:value :range];
+      }
+  ];
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if (range.length >= 1) {
+    return [OccurenceUtils detect:ImageAttributeName withInput:_input inRange:range
+        withCondition:^BOOL(id  _Nullable value, NSRange range) {
+            return [self styleCondition:value :range];
+        }
+    ];
+  } else {
+    return [OccurenceUtils detect:ImageAttributeName withInput:_input atIndex:range.location checkPrevious:YES
+        withCondition:^BOOL(id  _Nullable value, NSRange range) {
+            return [self styleCondition:value :range];
+        }
+    ];
+  }
+}
+
+- (NSArray<StylePair *> * _Nullable)findAllOccurences:(NSRange)range {
+  return [OccurenceUtils all:ImageAttributeName withInput:_input inRange:range
+      withCondition:^BOOL(id  _Nullable value, NSRange range) {
+          return [self styleCondition:value :range];
+      }
+  ];
+}
+
+- (ImageData *)getImageDataAt:(NSUInteger)location
+{
+  NSRange imageRange = NSMakeRange(0, 0);
+  NSRange inputRange = NSMakeRange(0, _input->textView.textStorage.length);
+  
+  // don't search at the very end of input
+  NSUInteger searchLocation = location;
+  if(searchLocation == _input->textView.textStorage.length) {
+    return nullptr;
+  }
+  
+  ImageData *imageData = [_input->textView.textStorage
+    attribute:ImageAttributeName
+    atIndex:searchLocation
+    longestEffectiveRange: &imageRange
+    inRange:inputRange
+  ];
+  
+  return imageData;
+}
+
+- (void)addImageAtRange:(NSRange)range imageData:(ImageData *)imageData withSelection:(BOOL)withSelection
+{
+  UIImage *img = [self prepareImageFromUri:imageData.uri];
+    
+  NSDictionary *attributes = [@{
+    NSAttachmentAttributeName: [self prepareImageAttachement:img width:imageData.width height:imageData.height],
+    ImageAttributeName: imageData,
+  } mutableCopy];
+  
+  // Use the Object Replacement Character for Image.
+  // This tells TextKit "something non-text goes here".
+  NSString *imagePlaceholder = @"\uFFFC";
+  
+  if (range.length == 0) {
+    [TextInsertionUtils insertText:imagePlaceholder at:range.location additionalAttributes:attributes input:_input withSelection:withSelection];
+  } else {
+    [TextInsertionUtils replaceText:imagePlaceholder
+                                 at:range
+               additionalAttributes:attributes
+                              input:_input
+                      withSelection:withSelection];
+  }
+}
+
+- (void)addImage:(NSString *)uri width:(CGFloat)width height:(CGFloat)height {
+  ImageData *data = [[ImageData alloc] init];
+  data.uri = uri;
+  data.width = width;
+  data.height = height;
+  
+  [self addImageAtRange:_input->textView.selectedRange imageData:data withSelection:YES];
+}
+
+-(NSTextAttachment *)prepareImageAttachement:(UIImage *)image width:(CGFloat)width height:(CGFloat)height
+{
+  
+  NSTextAttachment *attachment = [[NSTextAttachment alloc] init];
+  attachment.image = image;
+  attachment.bounds = CGRectMake(0, 0, width, height);
+
+  return attachment;
+}
+
+- (UIImage *)prepareImageFromUri:(NSString *)uri
+{
+  NSURL *url = [NSURL URLWithString:uri];
+  NSData *imgData = [NSData dataWithContentsOfURL:url];
+  UIImage *image = [UIImage imageWithData:imgData];
+  
+  return image;
+}
+
+@end

package/ios/styles/InlineCodeStyle.mm

@@ -11,6 +11,8 @@
 
 + (StyleType)getStyleType { return InlineCode; }
 
++ (BOOL)isParagraphStyle { return NO; }
+
 - (instancetype)initWithInput:(id)input {
   self = [super init];
   _input = (EnrichedTextInputView *)input;

package/ios/styles/ItalicStyle.mm

@@ -9,6 +9,8 @@
 
 + (StyleType)getStyleType { return Italic; }
 
++ (BOOL)isParagraphStyle { return NO; }
+
 - (instancetype)initWithInput:(id)input {
   self = [super init];
   _input = (EnrichedTextInputView *)input;

package/ios/styles/LinkStyle.mm

@@ -15,6 +15,8 @@ static NSString *const AutomaticLinkAttributeName = @"AutomaticLinkAttributeName
 
 + (StyleType)getStyleType { return Link; }
 
++ (BOOL)isParagraphStyle { return NO; }
+
 - (instancetype)initWithInput:(id)input {
   self = [super init];
   _input = (EnrichedTextInputView *)input;
@@ -280,6 +282,7 @@ static NSString *const AutomaticLinkAttributeName = @"AutomaticLinkAttributeName
 - (void)handleAutomaticLinks:(NSString *)word inRange:(NSRange)wordRange {
   InlineCodeStyle *inlineCodeStyle = [_input->stylesDict objectForKey:@([InlineCodeStyle getStyleType])];
   MentionStyle *mentionStyle = [_input->stylesDict objectForKey:@([MentionStyle getStyleType])];
+  CodeBlockStyle *codeBlockStyle = [_input->stylesDict objectForKey:@([CodeBlockStyle getStyleType])];
   
   if (inlineCodeStyle == nullptr || mentionStyle == nullptr) {
     return;
@@ -295,6 +298,11 @@ static NSString *const AutomaticLinkAttributeName = @"AutomaticLinkAttributeName
     return;
   }
   
+  // we don't recognize links in codeblocks
+  if ([codeBlockStyle anyOccurence:wordRange]) {
+    return;
+  }
+  
   // remove connected different links
   [self removeConnectedLinksIfNeeded:word range:wordRange];
   

package/ios/styles/MentionStyle.mm

@@ -18,6 +18,8 @@ static NSString *const MentionAttributeName = @"MentionAttributeName";
 
 + (StyleType)getStyleType { return Mention; }
 
++ (BOOL)isParagraphStyle { return NO; }
+
 - (instancetype)initWithInput:(id)input {
   self = [super init];
   _input = (EnrichedTextInputView *)input;
@@ -297,52 +299,37 @@ static NSString *const MentionAttributeName = @"MentionAttributeName";
     return;
   }
   
-  // get the current word if it exists
-  // we can be using current word only thanks to the fact that ongoing mentions are always one word (in contrast to ready, added mentions)
-  NSDictionary *currentWord = [WordsUtils getCurrentWord:_input->textView.textStorage.string range:_input->textView.selectedRange];
-  if(currentWord == nullptr) {
-    [self removeActiveMentionRange];
-    return;
-  }
-  
-  // get word properties
-  NSString *wordText = (NSString *)[currentWord objectForKey:@"word"];
-  NSValue *wordRangeValue = (NSValue *)[currentWord objectForKey:@"range"];
-  if(wordText == nullptr || wordRangeValue == nullptr) {
+  // get the text (and its range) that could be an editable mention
+  NSArray *mentionCandidate = [self getMentionCandidate];
+  if(mentionCandidate == nullptr) {
     [self removeActiveMentionRange];
     return;
   }
-  NSRange wordRange = [wordRangeValue rangeValue];
-  
-  // check for mentionIndicators - no sign of them means we shouldn't be editing a mention
-  unichar firstChar = [wordText characterAtIndex:0];
-  if(![[_input->config mentionIndicators] containsObject: @(firstChar)]) {
-    [self removeActiveMentionRange];
-    return;
-  }
-  
-  // check for existing mentions - we don't edit them
-  if([self detectStyle:wordRange]) {
-    [self removeActiveMentionRange];
-    return;
-  }
-  
-  // get conflicting style classes
-  LinkStyle* linkStyle = [_input->stylesDict objectForKey:@([LinkStyle getStyleType])];
-  InlineCodeStyle* inlineCodeStyle = [_input->stylesDict objectForKey:@([InlineCodeStyle getStyleType])];
-  if(linkStyle == nullptr || inlineCodeStyle == nullptr) {
-    [self removeActiveMentionRange];
-    return;
+  NSString *candidateText = mentionCandidate[0];
+  NSRange candidateRange = [(NSValue *)mentionCandidate[1] rangeValue];
+  
+  // get style classes that the mention shouldn't be recognized in, together with other mentions
+  NSArray *conflicts = _input->conflictingStyles[@([MentionStyle getStyleType])];
+  NSArray *blocks = _input->blockingStyles[@([MentionStyle getStyleType])];
+  NSArray *allConflicts = [[conflicts arrayByAddingObjectsFromArray:blocks] arrayByAddingObject:@([MentionStyle getStyleType])];
+  BOOL conflictingStyle = NO;
+  
+  for(NSNumber *styleType in allConflicts) {
+    id<BaseStyleProtocol> styleClass = _input->stylesDict[styleType];
+    if(styleClass != nullptr && [styleClass anyOccurence:candidateRange]) {
+      conflictingStyle = YES;
+      break;
+    }
   }
   
-  // if there is any sign of conflicting style classes, stop editing a mention
-  if([linkStyle anyOccurence:wordRange] || [inlineCodeStyle anyOccurence:wordRange]) {
+  // if any of the conflicting styles were present, don't edit the mention
+  if(conflictingStyle) {
     [self removeActiveMentionRange];
     return;
   }
   
   // everything checks out - we are indeed editing a mention
-  [self setActiveMentionRange:wordRange text:wordText];
+  [self setActiveMentionRange:candidateRange text:candidateText];
 }
 
 // used to fix mentions' typing attributes
@@ -454,6 +441,116 @@ static NSString *const MentionAttributeName = @"MentionAttributeName";
   return [_input->config mentionStylePropsForIndicator:params.indicator];
 }
 
+// finds if any word/words around current selection are eligible to be edited as mentions
+// since we allow for a single space inside an edited mention, we have take both current and the previous word into account
+- (NSArray *)getMentionCandidate {
+  NSDictionary *currentWord, *previousWord;
+  NSString *currentWordText, *previousWordText, *finalText;
+  NSValue *currentWordRange, *previousWordRange;
+  NSRange finalRange;
+  
+  // word at the current selection
+  currentWord = [WordsUtils getCurrentWord:_input->textView.textStorage.string range:_input->textView.selectedRange];
+  if(currentWord != nullptr ) {
+    currentWordText = (NSString *)[currentWord objectForKey:@"word"];
+    currentWordRange = (NSValue *)[currentWord objectForKey:@"range"];
+  }
+    
+  if(currentWord != nullptr) {
+    // current word exists
+    unichar currentFirstChar = [currentWordText characterAtIndex:0];
+    
+    if([[_input->config mentionIndicators] containsObject:@(currentFirstChar)]) {
+      // current word exists and has a mention indicator; no need to check for the previous word
+      finalText = currentWordText;
+      finalRange = [currentWordRange rangeValue];
+    } else {
+      // current word exists but no traces of mention indicator; get the previous word
+      
+      NSInteger previousWordSearchLocation = [currentWordRange rangeValue].location - 1;
+      if(previousWordSearchLocation < 0) {
+        // previous word can't exist
+        return nullptr;
+      }
+      
+      unichar separatorChar = [_input->textView.textStorage.string characterAtIndex:previousWordSearchLocation];
+      if(![[NSCharacterSet whitespaceCharacterSet] characterIsMember:separatorChar]) {
+        // we want to check for the previous word ONLY if the separating character was a space
+        // newlines don't make it
+        return nullptr;
+      }
+      
+      previousWord = [WordsUtils getCurrentWord:_input->textView.textStorage.string range:NSMakeRange(previousWordSearchLocation, 0)];
+      
+      if(previousWord != nullptr) {
+        // previous word exists; get its properties
+        previousWordText = (NSString *)[previousWord objectForKey:@"word"];
+        previousWordRange = (NSValue *)[previousWord objectForKey:@"range"];
+      
+        // check for the mention indicators in the previous word
+        unichar previousFirstChar = [previousWordText characterAtIndex:0];
+        
+        if([[_input->config mentionIndicators] containsObject:@(previousFirstChar) ]) {
+          // previous word has a proper mention indicator: treat both words as an editable mention
+          finalText = [NSString stringWithFormat:@"%@ %@", previousWordText, currentWordText];
+          // range length is both words' lengths + 1 for a space between them
+          finalRange = NSMakeRange(
+            [previousWordRange rangeValue].location,
+            [previousWordRange rangeValue].length + [currentWordRange rangeValue].length + 1
+          );
+        } else {
+          // neither current nor previous words have a mention indicator
+          return nullptr;
+        }
+      } else {
+        // previous word doesn't exist and no mention indicators in the current word
+        return nullptr;
+      }
+    }
+  } else {
+    // current word doesn't exist; try getting the previous one
+    
+    NSInteger previousWordSearchLocation = _input->textView.selectedRange.location - 1;
+    if(previousWordSearchLocation < 0) {
+      // previous word can't exist
+      return nullptr;
+    }
+    
+    unichar separatorChar = [_input->textView.textStorage.string characterAtIndex:previousWordSearchLocation];
+    if(![[NSCharacterSet whitespaceCharacterSet] characterIsMember:separatorChar]) {
+      // we want to check for the previous word ONLY if the separating character was a space
+      // newlines don't make it
+      return nullptr;
+    }
+    
+    previousWord = [WordsUtils getCurrentWord:_input->textView.textStorage.string range:NSMakeRange(previousWordSearchLocation, 0)];
+      
+    if(previousWord != nullptr) {
+      // previous word exists; get its properties
+      previousWordText = (NSString *)[previousWord objectForKey:@"word"];
+      previousWordRange = (NSValue *)[previousWord objectForKey:@"range"];
+      
+      // check for the mention indicators in the previous word
+      unichar previousFirstChar = [previousWordText characterAtIndex:0];
+      
+      if([[_input->config mentionIndicators] containsObject:@(previousFirstChar)]) {
+        // previous word has a proper mention indicator; treat previous word + a space as a editable mention
+        finalText = [NSString stringWithFormat:@"%@ ", previousWordText];
+        // the range length is previous word length + 1 for a space
+        finalRange = NSMakeRange([previousWordRange rangeValue].location, [previousWordRange rangeValue].length + 1);
+      } else {
+        // no current word, previous has no mention indicators
+        return nullptr;
+      }
+    } else {
+      // no current word, no previous word
+      return nullptr;
+    }
+  }
+  
+  return @[finalText, [NSValue valueWithRange:finalRange]];
+}
+
 // both used for setting the active mention range + indicator and fires proper onMention event
 - (void)setActiveMentionRange:(NSRange)range text:(NSString *)text {
   NSString *indicatorString = [NSString stringWithFormat:@"%C", [text characterAtIndex:0]];

package/ios/styles/OrderedListStyle.mm

@@ -11,6 +11,8 @@
 
 + (StyleType)getStyleType { return OrderedList; }
 
++ (BOOL)isParagraphStyle { return YES; }
+
 - (CGFloat)getHeadIndent {
   // lists are drawn manually
   // margin before marker + gap between marker and paragraph

package/ios/styles/StrikethroughStyle.mm

@@ -8,6 +8,8 @@
 
 + (StyleType)getStyleType { return Strikethrough; }
 
++ (BOOL)isParagraphStyle { return NO; }
+
 - (instancetype)initWithInput:(id)input {
   self = [super init];
   _input = (EnrichedTextInputView *)input;