react-native-enriched-html 0.0.0 → 1.0.1

package/ios/styles/MentionStyle.mm

@@ -0,0 +1,592 @@
+#import "AttributeEntry.h"
+#import "ColorExtension.h"
+#import "EnrichedTextInputView.h"
+#import "StyleHeaders.h"
+#import "TextInsertionUtils.h"
+#import "UIView+React.h"
+#import "WordsUtils.h"
+
+// custom NSAttributedStringKey to differentiate from links
+static NSString *const MentionAttributeName = @"EnrichedMention";
+
+@implementation MentionStyle {
+  NSValue *_activeMentionRange;
+  NSString *_activeMentionIndicator;
+  BOOL _blockMentionEditing;
+  NSString *_lastEmittedMentionIndicator;
+  NSString *_lastEmittedMentionText;
+}
+
++ (StyleType)getType {
+  return Mention;
+}
+
+- (NSString *)getKey {
+  return MentionAttributeName;
+}
+
+- (BOOL)isParagraph {
+  return NO;
+}
+
+- (instancetype)initWithHost:(id<EnrichedViewHost>)host {
+  self = [super initWithHost:host];
+  if (self) {
+    _activeMentionRange = nullptr;
+    _activeMentionIndicator = nullptr;
+    _blockMentionEditing = NO;
+  }
+  return self;
+}
+
+- (void)applyStyling:(NSRange)range {
+  if (range.length == 0) {
+    return;
+  }
+  MentionParams *params = [self getMentionParamsAt:range.location];
+  if (params == nullptr) {
+    return;
+  }
+
+  MentionStyleProps *styleProps =
+      [self.host.config mentionStylePropsForIndicator:params.indicator];
+
+  NSMutableDictionary *newAttrs = [@{
+    NSForegroundColorAttributeName : styleProps.color,
+    NSUnderlineColorAttributeName : styleProps.color,
+    NSStrikethroughColorAttributeName : styleProps.color,
+    NSBackgroundColorAttributeName :
+        [styleProps.backgroundColor colorWithResolvedAlpha],
+  } mutableCopy];
+
+  if (styleProps.decorationLine == DecorationUnderline) {
+    newAttrs[NSUnderlineStyleAttributeName] = @(NSUnderlineStyleSingle);
+  }
+
+  [self.host.textView.textStorage addAttributes:newAttrs range:range];
+}
+
+- (void)reapplyFromStylePair:(StylePair *)pair {
+  NSRange range = [pair.rangeValue rangeValue];
+  MentionParams *params = (MentionParams *)pair.styleValue;
+  if (params == nullptr) {
+    return;
+  }
+  [self applyMentionMeta:params range:range];
+}
+
+// we don't want the mention to be extended, thus returning nullptr here.
+- (AttributeEntry *)getEntryIfPresent:(NSRange)range {
+  return nullptr;
+}
+
+- (void)toggle:(NSRange)range {
+  // no-op for mentions
+}
+
+// Strip meta only, InputAttributesManager dirty pass resets visuals and
+// reapplies other styles
+- (void)remove:(NSRange)range withDirtyRange:(BOOL)withDirtyRange {
+  NSArray<StylePair *> *mentions = [self all:range];
+  [self.host.textView.textStorage beginEditing];
+  for (StylePair *pair in mentions) {
+    NSRange mentionRange =
+        [self getFullMentionRangeAt:[pair.rangeValue rangeValue].location];
+    if (mentionRange.length == 0) {
+      continue;
+    }
+    [self.host.textView.textStorage removeAttribute:MentionAttributeName
+                                              range:mentionRange];
+    if (withDirtyRange) {
+      [self.host.attributesManager addDirtyRange:mentionRange];
+    }
+  }
+  [self.host.textView.textStorage endEditing];
+
+  [super removeTyping];
+}
+
+// used for conflicts, we have to remove the whole mention
+- (void)removeTyping {
+  NSRange mentionRange =
+      [self getFullMentionRangeAt:self.host.textView.selectedRange.location];
+  if (mentionRange.length > 0) {
+    [self.host.textView.textStorage beginEditing];
+    [self.host.textView.textStorage removeAttribute:MentionAttributeName
+                                              range:mentionRange];
+    [self.host.textView.textStorage endEditing];
+    [self.host.attributesManager addDirtyRange:mentionRange];
+  }
+  [super removeTyping];
+}
+
+- (BOOL)styleCondition:(id _Nullable)value range:(NSRange)range {
+  MentionParams *params = (MentionParams *)value;
+  return params != nullptr;
+}
+
+- (BOOL)detect:(NSRange)range {
+  if (range.length >= 1) {
+    return [super detect:range];
+  }
+  return [self getMentionParamsAt:range.location] != nullptr;
+}
+
+- (void)applyMentionMeta:(MentionParams *)params range:(NSRange)range {
+  [self.host.textView.textStorage addAttribute:MentionAttributeName
+                                         value:params
+                                         range:range];
+}
+
+// MARK: - Public non-standard methods
+
+- (void)addMention:(NSString *)indicator
+              text:(NSString *)text
+        attributes:(NSString *)attributes {
+  if (_activeMentionRange == nullptr) {
+    // No draft mention (indicator not typed) - fall back to the current
+    // selection.
+    _activeMentionRange =
+        [NSValue valueWithRange:self.host.textView.selectedRange];
+    _activeMentionIndicator = indicator;
+  }
+
+  _blockMentionEditing = YES;
+
+  MentionParams *params = [[MentionParams alloc] init];
+  params.text = text;
+  params.indicator = indicator;
+  params.attributes = attributes;
+
+  NSRange rangeToBeReplaced = [_activeMentionRange rangeValue];
+
+  // add a single space after the mention if there isn't one already
+  BOOL hasSpaceAfter = NO;
+  NSUInteger nextCharIndex =
+      rangeToBeReplaced.location + rangeToBeReplaced.length;
+
+  if (nextCharIndex < self.host.textView.textStorage.string.length) {
+    unichar nextChar =
+        [self.host.textView.textStorage.string characterAtIndex:nextCharIndex];
+    if ([[NSCharacterSet whitespaceCharacterSet] characterIsMember:nextChar]) {
+      hasSpaceAfter = YES;
+    }
+  }
+
+  NSString *newText =
+      hasSpaceAfter ? text : [NSString stringWithFormat:@"%@ ", text];
+
+  [TextInsertionUtils replaceText:newText
+                               at:rangeToBeReplaced
+             additionalAttributes:nullptr
+                             host:self.host
+                    withSelection:YES];
+
+  // we always want the cursor to end up after the trailing space, so when we
+  // reused an existing space (and didn't insert our own) move it one to the
+  // right
+  if (hasSpaceAfter) {
+    NSRange selection = self.host.textView.selectedRange;
+    self.host.textView.selectedRange = NSMakeRange(selection.location + 1, 0);
+  }
+
+  // THEN, add the attributes to not apply them on the space
+  NSRange mentionRange = NSMakeRange(rangeToBeReplaced.location, text.length);
+  [self applyMentionMeta:params range:mentionRange];
+  [self.host.attributesManager addDirtyRange:mentionRange];
+  // mention editing should finish
+  [self removeActiveMentionRange];
+
+  _blockMentionEditing = NO;
+}
+
+- (void)addMentionAtRange:(NSRange)range params:(MentionParams *)params {
+  _blockMentionEditing = YES;
+
+  [self applyMentionMeta:params range:range];
+  [self.host.attributesManager addDirtyRange:range];
+
+  _blockMentionEditing = NO;
+}
+
+- (void)startMentionWithIndicator:(NSString *)indicator {
+  NSRange currentRange = self.host.textView.selectedRange;
+
+  BOOL addSpaceBefore = NO;
+  BOOL addSpaceAfter = NO;
+
+  if (currentRange.location > 0) {
+    unichar charBefore = [self.host.textView.textStorage.string
+        characterAtIndex:(currentRange.location - 1)];
+    if (![[NSCharacterSet whitespaceAndNewlineCharacterSet]
+            characterIsMember:charBefore]) {
+      addSpaceBefore = YES;
+    }
+  }
+
+  if (currentRange.location + currentRange.length <
+      self.host.textView.textStorage.string.length) {
+    unichar charAfter = [self.host.textView.textStorage.string
+        characterAtIndex:(currentRange.location + currentRange.length)];
+    if (![[NSCharacterSet whitespaceAndNewlineCharacterSet]
+            characterIsMember:charAfter]) {
+      addSpaceAfter = YES;
+    }
+  }
+
+  NSString *finalString =
+      [NSString stringWithFormat:@"%@%@%@", addSpaceBefore ? @" " : @"",
+                                 indicator, addSpaceAfter ? @" " : @""];
+
+  NSRange newSelect = NSMakeRange(
+      currentRange.location + finalString.length + (addSpaceAfter ? -1 : 0), 0);
+
+  if (currentRange.length == 0) {
+    [TextInsertionUtils insertText:finalString
+                                at:currentRange.location
+              additionalAttributes:nullptr
+                              host:self.host
+                     withSelection:NO];
+  } else {
+    [TextInsertionUtils replaceText:finalString
+                                 at:currentRange
+               additionalAttributes:nullptr
+                               host:self.host
+                      withSelection:NO];
+  }
+
+  [self.host.textView reactFocus];
+  self.host.textView.selectedRange = newSelect;
+}
+
+// handles removing no longer valid mentions
+- (void)handleExistingMentions {
+  // unfortunately whole text needs to be checked for them
+  // checking the modified words doesn't work because mention's text can have
+  // any number of spaces, which makes one mention any number of words long
+
+  NSRange wholeText =
+      NSMakeRange(0, self.host.textView.textStorage.string.length);
+  // get mentions in ascending range.location order
+  NSArray<StylePair *> *mentions = [[self all:wholeText]
+      sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1,
+                                                     id _Nonnull obj2) {
+        NSRange range1 = [((StylePair *)obj1).rangeValue rangeValue];
+        NSRange range2 = [((StylePair *)obj2).rangeValue rangeValue];
+        if (range1.location < range2.location) {
+          return NSOrderedAscending;
+        }
+        return NSOrderedDescending;
+      }];
+
+  // set of ranges to have their mentions removed - aren't valid anymore
+  NSMutableSet<NSValue *> *rangesToRemove = [[NSMutableSet alloc] init];
+
+  for (NSInteger i = 0; i < mentions.count; i++) {
+    StylePair *mention = mentions[i];
+    NSRange currentRange = [mention.rangeValue rangeValue];
+    NSString *currentText = ((MentionParams *)mention.styleValue).text;
+    // check locations with the previous mention if it exists - if they got
+    // merged they need to be removed
+    if (i > 0) {
+      NSRange prevRange =
+          [((StylePair *)mentions[i - 1]).rangeValue rangeValue];
+      // mentions merged - both need to go out
+      if (prevRange.location + prevRange.length == currentRange.location) {
+        [rangesToRemove addObject:[NSValue valueWithRange:prevRange]];
+        [rangesToRemove addObject:[NSValue valueWithRange:currentRange]];
+        continue;
+      }
+    }
+
+    // check for text, any modifications to it makes mention invalid
+    NSString *existingText =
+        [self.host.textView.textStorage.string substringWithRange:currentRange];
+    if (![existingText isEqualToString:currentText]) {
+      [rangesToRemove addObject:[NSValue valueWithRange:currentRange]];
+    }
+  }
+
+  for (NSValue *value in rangesToRemove) {
+    [self remove:[value rangeValue] withDirtyRange:YES];
+  }
+}
+
+// manages active mention range, which in turn emits proper onMention event
+- (void)manageMentionEditing {
+  // no actions performed when block is active
+  if (_blockMentionEditing) {
+    return;
+  }
+
+  // we don't take longer selections into consideration
+  if (self.host.textView.selectedRange.length > 0) {
+    [self removeActiveMentionRange];
+    return;
+  }
+
+  // get the text (and its range) that could be an editable mention
+  NSArray *mentionCandidate = [self getMentionCandidate];
+  if (mentionCandidate == 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 = self.host.conflictingStyles[@([MentionStyle getType])];
+  NSArray *blocks = self.host.blockingStyles[@([MentionStyle getType])];
+  NSArray *allConflicts = [[conflicts arrayByAddingObjectsFromArray:blocks]
+      arrayByAddingObject:@([MentionStyle getType])];
+  BOOL conflictingStyle = NO;
+
+  for (NSNumber *styleType in allConflicts) {
+    StyleBase *styleInst = self.host.stylesDict[styleType];
+    if (styleInst != nullptr && [styleInst any:candidateRange]) {
+      conflictingStyle = YES;
+      break;
+    }
+  }
+
+  // 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:candidateRange text:candidateText];
+}
+
+// returns mention params if it exists
+- (MentionParams *)getMentionParamsAt:(NSUInteger)location {
+  NSRange mentionRange = NSMakeRange(0, 0);
+  NSRange inputRange = NSMakeRange(0, self.host.textView.textStorage.length);
+
+  // don't search at the very end of input
+  NSUInteger searchLocation = location;
+  if (searchLocation == self.host.textView.textStorage.length) {
+    return nullptr;
+  }
+
+  MentionParams *value =
+      [self.host.textView.textStorage attribute:MentionAttributeName
+                                        atIndex:searchLocation
+                          longestEffectiveRange:&mentionRange
+                                        inRange:inputRange];
+  return value;
+}
+
+- (NSValue *)getActiveMentionRange {
+  return _activeMentionRange;
+}
+
+// returns full range of a mention at some location
+- (NSRange)getFullMentionRangeAt:(NSUInteger)location {
+  NSRange mentionRange = NSMakeRange(0, 0);
+  NSRange inputRange = NSMakeRange(0, self.host.textView.textStorage.length);
+
+  // get the previous index if possible when at the very end of input
+  NSUInteger searchLocation = location;
+  if (searchLocation == self.host.textView.textStorage.length) {
+    if (searchLocation == 0) {
+      return mentionRange;
+    }
+    searchLocation = searchLocation - 1;
+  }
+
+  [self.host.textView.textStorage attribute:MentionAttributeName
+                                    atIndex:searchLocation
+                      longestEffectiveRange:&mentionRange
+                                    inRange:inputRange];
+  return mentionRange;
+}
+
+- (MentionStyleProps *)stylePropsWithParams:(MentionParams *)params {
+  return [self.host.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:self.host.textView.textStorage.string
+                                     range:self.host.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 ([[self.host.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 = [self.host.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:self.host.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 ([[self.host.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 =
+        self.host.textView.selectedRange.location - 1;
+    if (previousWordSearchLocation < 0) {
+      // previous word can't exist
+      return nullptr;
+    }
+
+    unichar separatorChar = [self.host.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:self.host.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 ([[self.host.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]];
+  NSString *textString =
+      [text substringWithRange:NSMakeRange(1, text.length - 1)];
+
+  BOOL startMention = NO;
+
+  // switching directly to an active mention
+  if (![_activeMentionIndicator isEqualToString:indicatorString]) {
+    startMention = YES;
+    [self removeActiveMentionRange];
+  }
+
+  // explicit startMention event before changeMention event
+  if (startMention && textString.length > 0) {
+    [self emitOnMentionEvent:indicatorString text:@""];
+  }
+
+  [self emitOnMentionEvent:indicatorString text:textString];
+
+  _activeMentionIndicator = indicatorString;
+  _activeMentionRange = [NSValue valueWithRange:range];
+}
+
+// removes stored mention range + indicator, which means that we no longer edit
+// a mention and onMention event gets fired
+- (void)removeActiveMentionRange {
+  if (_activeMentionIndicator != nullptr && _activeMentionRange != nullptr) {
+    NSString *indicatorCopy = [_activeMentionIndicator copy];
+    _activeMentionIndicator = nullptr;
+    _activeMentionRange = nullptr;
+    [self emitOnMentionEvent:indicatorCopy text:nullptr];
+  }
+}
+
+- (void)emitOnMentionEvent:(NSString *)indicator text:(NSString *)text {
+  BOOL sameText = (_lastEmittedMentionText == nullptr && text == nullptr) ||
+                  [_lastEmittedMentionText isEqualToString:text];
+
+  if (![_lastEmittedMentionIndicator isEqualToString:indicator] || !sameText) {
+    [self.host emitOnMentionEvent:indicator text:text];
+    _lastEmittedMentionIndicator = indicator;
+    _lastEmittedMentionText = text;
+  }
+}
+
+@end

package/ios/styles/OrderedListStyle.mm

@@ -0,0 +1,48 @@
+#import "EnrichedTextInputView.h"
+#import "RangeUtils.h"
+#import "StyleHeaders.h"
+#import "StyleUtils.h"
+#import "TextInsertionUtils.h"
+
+@implementation OrderedListStyle
+
++ (StyleType)getType {
+  return OrderedList;
+}
+
+- (NSString *)getValue {
+  return @"EnrichedOrderedList";
+}
+
+- (BOOL)isParagraph {
+  return YES;
+}
+
+- (BOOL)needsZWS {
+  return YES;
+}
+
+- (void)applyStyling:(NSRange)range {
+  // lists are drawn manually
+  // margin before marker + gap between marker and paragraph
+  CGFloat listHeadIndent = [self.host.config orderedListMarginLeft] +
+                           [self.host.config orderedListGapWidth];
+
+  [self.host.textView.textStorage
+      enumerateAttribute:NSParagraphStyleAttributeName
+                 inRange:range
+                 options:0
+              usingBlock:^(id _Nullable value, NSRange range,
+                           BOOL *_Nonnull stop) {
+                NSMutableParagraphStyle *pStyle =
+                    [(NSParagraphStyle *)value mutableCopy];
+                pStyle.headIndent = listHeadIndent;
+                pStyle.firstLineHeadIndent = listHeadIndent;
+                [self.host.textView.textStorage
+                    addAttribute:NSParagraphStyleAttributeName
+                           value:pStyle
+                           range:range];
+              }];
+}
+
+@end

package/ios/styles/StrikethroughStyle.mm

@@ -0,0 +1,25 @@
+#import "EnrichedTextInputView.h"
+#import "StyleHeaders.h"
+
+@implementation StrikethroughStyle : StyleBase
+
++ (StyleType)getType {
+  return Strikethrough;
+}
+
+- (NSString *)getKey {
+  return @"EnrichedStrikethrough";
+}
+
+- (BOOL)isParagraph {
+  return NO;
+}
+
+- (void)applyStyling:(NSRange)range {
+  [self.host.textView.textStorage addAttributes:@{
+    NSStrikethroughStyleAttributeName : @(NSUnderlineStyleSingle)
+  }
+                                          range:range];
+}
+
+@end

package/ios/styles/UnderlineStyle.mm

@@ -0,0 +1,24 @@
+#import "EnrichedTextInputView.h"
+#import "StyleHeaders.h"
+
+@implementation UnderlineStyle
+
++ (StyleType)getType {
+  return Underline;
+}
+
+- (NSString *)getKey {
+  return @"EnrichedUnderline";
+}
+
+- (BOOL)isParagraph {
+  return NO;
+}
+
+- (void)applyStyling:(NSRange)range {
+  [self.host.textView.textStorage addAttribute:NSUnderlineStyleAttributeName
+                                         value:@(NSUnderlineStyleSingle)
+                                         range:range];
+}
+
+@end