react-native-enriched 0.0.0 → 0.1.0

package/ios/styles/MentionStyle.mm

@@ -0,0 +1,476 @@
+#import "StyleHeaders.h"
+#import "EnrichedTextInputView.h"
+#import "OccurenceUtils.h"
+#import "TextInsertionUtils.h"
+#import "WordsUtils.h"
+#import "UIView+React.h"
+
+// custom NSAttributedStringKey to differentiate from links
+static NSString *const MentionAttributeName = @"MentionAttributeName";
+
+@implementation MentionStyle {
+  EnrichedTextInputView*_input;
+  NSValue *_activeMentionRange;
+  NSString *_activeMentionIndicator;
+  BOOL _blockMentionEditing;
+}
+
++ (StyleType)getStyleType { return Mention; }
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  _activeMentionRange = nullptr;
+  _activeMentionIndicator = nullptr;
+  _blockMentionEditing = NO;
+  return self;
+}
+
+- (void)applyStyle:(NSRange)range {
+  // no-op for mentions
+}
+
+- (void)addAttributes:(NSRange)range {
+  // no-op for mentions
+}
+
+- (void)addTypingAttributes {
+  // no-op for mentions
+}
+
+// we have to make sure all mentions get removed properly
+- (void)removeAttributes:(NSRange)range {
+  BOOL someMentionHadUnderline = NO;
+
+  NSArray<StylePair *> *mentions = [self findAllOccurences:range];
+  [_input->textView.textStorage beginEditing];
+  for(StylePair *pair in mentions) {
+    NSRange mentionRange = [self getFullMentionRangeAt:[pair.rangeValue rangeValue].location];
+    [_input->textView.textStorage removeAttribute:MentionAttributeName range:mentionRange];
+    [_input->textView.textStorage addAttribute:NSForegroundColorAttributeName value:[_input->config primaryColor] range:mentionRange];
+    [_input->textView.textStorage addAttribute:NSUnderlineColorAttributeName value:[_input->config primaryColor] range:mentionRange];
+    [_input->textView.textStorage addAttribute:NSStrikethroughColorAttributeName value:[_input->config primaryColor] range:mentionRange];
+    [_input->textView.textStorage removeAttribute:NSBackgroundColorAttributeName range:mentionRange];
+    
+    if([self stylePropsWithParams:pair.styleValue].decorationLine == DecorationUnderline) {
+      [_input->textView.textStorage removeAttribute:NSUnderlineStyleAttributeName range:mentionRange];
+      someMentionHadUnderline = YES;
+    }
+  }
+  [_input->textView.textStorage endEditing];
+  
+  // remove typing attributes as well
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  newTypingAttrs[NSForegroundColorAttributeName] = [_input->config primaryColor];
+  newTypingAttrs[NSUnderlineColorAttributeName] = [_input->config primaryColor];
+  newTypingAttrs[NSStrikethroughColorAttributeName] = [_input->config primaryColor];
+  [newTypingAttrs removeObjectForKey:NSBackgroundColorAttributeName];
+  if(someMentionHadUnderline) {
+    [newTypingAttrs removeObjectForKey:NSUnderlineStyleAttributeName];
+  }
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+// used for conflicts, we have to remove the whole mention
+- (void)removeTypingAttributes {
+  NSRange mentionRange = [self getFullMentionRangeAt:_input->textView.selectedRange.location];
+  [_input->textView.textStorage beginEditing];
+  [_input->textView.textStorage removeAttribute:MentionAttributeName range:mentionRange];
+  [_input->textView.textStorage addAttribute:NSForegroundColorAttributeName value:[_input->config primaryColor] range:mentionRange];
+  [_input->textView.textStorage addAttribute:NSUnderlineColorAttributeName value:[_input->config primaryColor] range:mentionRange];
+  [_input->textView.textStorage addAttribute:NSStrikethroughColorAttributeName value:[_input->config primaryColor] range:mentionRange];
+  [_input->textView.textStorage removeAttribute:NSBackgroundColorAttributeName range:mentionRange];
+  
+  MentionParams *params = [self getMentionParamsAt:mentionRange.location];
+  if([self stylePropsWithParams:params].decorationLine == DecorationUnderline) {
+    [_input->textView.textStorage removeAttribute:NSUnderlineStyleAttributeName range:mentionRange];
+  }
+  [_input->textView.textStorage endEditing];
+  
+  // remove typing attributes as well
+  NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+  newTypingAttrs[NSForegroundColorAttributeName] = [_input->config primaryColor];
+  newTypingAttrs[NSUnderlineColorAttributeName] = [_input->config primaryColor];
+  newTypingAttrs[NSStrikethroughColorAttributeName] = [_input->config primaryColor];
+  [newTypingAttrs removeObjectForKey:NSBackgroundColorAttributeName];
+  if([self stylePropsWithParams:params].decorationLine == DecorationUnderline) {
+    [newTypingAttrs removeObjectForKey:NSUnderlineStyleAttributeName];
+  }
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (BOOL)styleCondition:(id _Nullable)value :(NSRange)range {
+  MentionParams *params = (MentionParams *)value;
+  return params != nullptr;
+}
+
+- (BOOL)detectStyle:(NSRange)range {
+  if(range.length >= 1) {
+    return [OccurenceUtils detect:MentionAttributeName withInput:_input inRange:range
+      withCondition: ^BOOL(id  _Nullable value, NSRange range) {
+        return [self styleCondition:value :range];
+      }
+    ];
+  } else {
+    return [self getMentionParamsAt:range.location] != nullptr;
+  }
+}
+
+- (BOOL)anyOccurence:(NSRange)range {
+  return [OccurenceUtils any:MentionAttributeName 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:MentionAttributeName withInput:_input inRange:range
+    withCondition:^BOOL(id  _Nullable value, NSRange range) {
+      return [self styleCondition:value :range];
+    }
+  ];
+}
+
+// MARK: - Public non-standard methods
+
+- (void)addMention:(NSString *)indicator text:(NSString *)text attributes:(NSString *)attributes {
+  if(_activeMentionRange == nullptr) {
+    return;
+  }
+  
+  // we block callbacks resulting from manageMentionEditing while we tamper with them here
+  _blockMentionEditing = YES;
+  
+  MentionParams *params = [[MentionParams alloc] init];
+  params.text = text;
+  params.indicator = indicator;
+  params.attributes = attributes;
+  
+  MentionStyleProps *styleProps = [_input->config mentionStylePropsForIndicator:indicator];
+  
+  NSMutableDictionary *newAttrs = [@{
+    MentionAttributeName: params,
+    NSForegroundColorAttributeName: styleProps.color,
+    NSUnderlineColorAttributeName: styleProps.color,
+    NSStrikethroughColorAttributeName: styleProps.color,
+    NSBackgroundColorAttributeName: [styleProps.backgroundColor colorWithAlphaComponent:0.4],
+  } mutableCopy];
+  
+  if(styleProps.decorationLine == DecorationUnderline) {
+    newAttrs[NSUnderlineStyleAttributeName] = @(NSUnderlineStyleSingle);
+  }
+  
+  // add a single space after the mention
+  NSString *newText = [NSString stringWithFormat:@"%@ ", text];
+  NSRange rangeToBeReplaced = [_activeMentionRange rangeValue];
+  [TextInsertionUtils replaceText:newText at:rangeToBeReplaced additionalAttributes:nullptr input:_input withSelection:YES];
+  
+  // THEN, add the attributes to not apply them on the space
+  [_input->textView.textStorage addAttributes:newAttrs range:NSMakeRange(rangeToBeReplaced.location, text.length)];
+  
+  // mention editing should finish
+  [self removeActiveMentionRange];
+  
+  // unlock editing
+  _blockMentionEditing = NO;
+}
+
+- (void)addMentionAtRange:(NSRange)range params:(MentionParams *)params {
+  _blockMentionEditing = YES;
+  
+  MentionStyleProps *styleProps = [_input->config mentionStylePropsForIndicator:params.indicator];
+  
+  NSMutableDictionary *newAttrs = [@{
+    MentionAttributeName: params,
+    NSForegroundColorAttributeName: styleProps.color,
+    NSUnderlineColorAttributeName: styleProps.color,
+    NSStrikethroughColorAttributeName: styleProps.color,
+    NSBackgroundColorAttributeName: [styleProps.backgroundColor colorWithAlphaComponent:0.4],
+  } mutableCopy];
+  
+  if(styleProps.decorationLine == DecorationUnderline) {
+    newAttrs[NSUnderlineStyleAttributeName] = @(NSUnderlineStyleSingle);
+  }
+  
+  [_input->textView.textStorage addAttributes:newAttrs range:range];
+  
+  _blockMentionEditing = NO;
+}
+
+- (void)startMentionWithIndicator:(NSString *)indicator {
+  NSRange currentRange = _input->textView.selectedRange;
+  
+  BOOL addSpaceBefore = NO;
+  BOOL addSpaceAfter = NO;
+  
+  if(currentRange.location > 0) {
+    unichar charBefore = [_input->textView.textStorage.string characterAtIndex:(currentRange.location - 1)];
+    if(![[NSCharacterSet whitespaceAndNewlineCharacterSet] characterIsMember:charBefore]) {
+      addSpaceBefore = YES;
+    }
+  }
+  
+  if(currentRange.location + currentRange.length < _input->textView.textStorage.string.length) {
+    unichar charAfter = [_input->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 input:_input withSelection:NO];
+  } else {
+    [TextInsertionUtils replaceText:finalString at:currentRange additionalAttributes:nullptr input:_input withSelection:NO];
+  }
+  
+  [_input->textView reactFocus];
+  _input->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, _input->textView.textStorage.string.length);
+  // get menntions in ascending range.location order
+  NSArray<StylePair *> *mentions = [[self findAllOccurences: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;
+    } else {
+      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 = [_input->textView.textStorage.string substringWithRange:currentRange];
+    if(![existingText isEqualToString:currentText]) {
+      [rangesToRemove addObject:[NSValue valueWithRange:currentRange]];
+    }
+  }
+  
+  for(NSValue *value in rangesToRemove) {
+    [self removeAttributes:[value rangeValue]];
+  }
+}
+
+// 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(_input->textView.selectedRange.length > 0) {
+    [self removeActiveMentionRange];
+    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) {
+    [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;
+  }
+  
+  // if there is any sign of conflicting style classes, stop editing a mention
+  if([linkStyle anyOccurence:wordRange] || [inlineCodeStyle anyOccurence:wordRange]) {
+    [self removeActiveMentionRange];
+    return;
+  }
+  
+  // everything checks out - we are indeed editing a mention
+  [self setActiveMentionRange:wordRange text:wordText];
+}
+
+// used to fix mentions' typing attributes
+- (void)manageMentionTypingAttributes {
+  // same as with links, mentions' typing attributes need to be constantly removed whenever we are somewhere near
+  BOOL removeAttrs = NO;
+  MentionParams *params;
+  
+  if(_input->textView.selectedRange.length == 0) {
+    // check before
+    if(_input->textView.selectedRange.location >= 1) {
+      if([self detectStyle:NSMakeRange(_input->textView.selectedRange.location - 1, 1)]) {
+        removeAttrs = YES;
+        params = [self getMentionParamsAt:_input->textView.selectedRange.location - 1];
+      }
+    }
+    // check after
+    if(_input->textView.selectedRange.location < _input->textView.textStorage.length) {
+      if([self detectStyle:NSMakeRange(_input->textView.selectedRange.location, 1)]) {
+        removeAttrs = YES;
+        params = [self getMentionParamsAt:_input->textView.selectedRange.location];
+      }
+    }
+  } else {
+    if([self anyOccurence:_input->textView.selectedRange]) {
+      removeAttrs = YES;
+    }
+  }
+  
+  if(removeAttrs) {
+    NSMutableDictionary *newTypingAttrs = [_input->textView.typingAttributes mutableCopy];
+    newTypingAttrs[NSForegroundColorAttributeName] = [_input->config primaryColor];
+    newTypingAttrs[NSUnderlineColorAttributeName] = [_input->config primaryColor];
+    newTypingAttrs[NSStrikethroughColorAttributeName] = [_input->config primaryColor];
+    [newTypingAttrs removeObjectForKey:NSBackgroundColorAttributeName];
+    if([self stylePropsWithParams:params].decorationLine == DecorationUnderline) {
+      [newTypingAttrs removeObjectForKey:NSUnderlineStyleAttributeName];
+    }
+    _input->textView.typingAttributes = newTypingAttrs;
+  }
+}
+
+// replacing whole input (that starts with a mention) with a manually typed letter improperly applies mention's attributes to all the following text
+- (BOOL)handleLeadingMentionReplacement:(NSRange)range replacementText:(NSString *)text {
+  // whole textView range gets replaced with a single letter
+  if(_input->textView.textStorage.string.length > 0 && NSEqualRanges(range, NSMakeRange(0, _input->textView.textStorage.string.length)) && text.length == 1) {
+    // first character detection is enough for the removal to be done
+    if([self detectStyle:NSMakeRange(0, 1)]) {
+      [self removeAttributes:NSMakeRange(0, _input->textView.textStorage.string.length)];
+      // do the replacing manually
+      [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:_input withSelection:YES];
+      return YES;
+    }
+  }
+  return NO;
+}
+
+// returns mention params if it exists
+- (MentionParams *)getMentionParamsAt:(NSUInteger)location {
+  NSRange mentionRange = 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;
+  }
+  
+  MentionParams *value = [_input->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, _input->textView.textStorage.length);
+  
+  // get the previous index if possible when at the very end of input
+  NSUInteger searchLocation = location;
+  if(searchLocation == _input->textView.textStorage.length) {
+    if(searchLocation == 0) {
+      return mentionRange;
+    } else {
+      searchLocation = searchLocation - 1;
+    }
+  }
+  
+  [_input->textView.textStorage
+   attribute:MentionAttributeName
+   atIndex:searchLocation
+   longestEffectiveRange: &mentionRange
+   inRange:inputRange
+  ];
+  return mentionRange;
+}
+
+// MARK: - Private non-standard methods
+
+- (MentionStyleProps *)stylePropsWithParams:(MentionParams *)params {
+  return [_input->config mentionStylePropsForIndicator:params.indicator];
+}
+
+// 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)];
+  _activeMentionIndicator = indicatorString;
+  _activeMentionRange = [NSValue valueWithRange:range];
+  [_input emitOnMentionEvent:indicatorString text:textString];
+}
+
+// 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;
+    [_input emitOnMentionEvent:indicatorCopy text:nullptr];
+  }
+}
+
+@end
+

package/ios/styles/OrderedListStyle.mm

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