react-native-enriched 0.1.5 → 0.2.0

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
@@ -158,18 +160,13 @@
     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;
-        }
+        // don't emit during the replacing
+        _input->blockEmitting = YES;
         
         // remove the number
         [TextInsertionUtils replaceText:@"" at:NSMakeRange(paragraphRange.location, 1) additionalAttributes:nullptr input:_input withSelection:YES];
         
-        if(prevEmitHtml) {
-          _input->emitHtml = YES;
-        }
+        _input->blockEmitting = NO;
         
         // add attributes on the paragraph
         [self addAttributes:NSMakeRange(paragraphRange.location, paragraphRange.length - 1)];

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;

package/ios/styles/UnderlineStyle.mm

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

package/ios/styles/UnorderedListStyle.mm

@@ -11,6 +11,8 @@
 
 + (StyleType)getStyleType { return UnorderedList; }
 
++ (BOOL)isParagraphStyle { return YES; }
+
 - (CGFloat)getHeadIndent {
   // lists are drawn manually
   // margin before bullet + gap between bullet and paragraph
@@ -158,18 +160,13 @@
     if(charBefore == '-') {
       // 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;
-        }
+        // don't emit during the replacing
+        _input->blockEmitting = YES;
         
         // remove the dash
         [TextInsertionUtils replaceText:@"" at:NSMakeRange(paragraphRange.location, 1) additionalAttributes:nullptr input:_input withSelection:YES];
         
-        if(prevEmitHtml) {
-          _input->emitHtml = YES;
-        }
+        _input->blockEmitting = NO;
         
         // add attributes on the dashless paragraph
         [self addAttributes:NSMakeRange(paragraphRange.location, paragraphRange.length - 1)];

package/ios/utils/BaseStyleProtocol.h

@@ -4,6 +4,7 @@
 
 @protocol BaseStyleProtocol <NSObject>
 + (StyleType)getStyleType;
++ (BOOL)isParagraphStyle;
 - (instancetype _Nonnull)initWithInput:(id _Nonnull)input;
 - (void)applyStyle:(NSRange)range;
 - (void)addAttributes:(NSRange)range;

package/ios/utils/ImageData.h

@@ -0,0 +1,10 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface ImageData : NSObject
+
+@property NSString *uri;
+@property CGFloat width;
+@property CGFloat height;
+
+@end

package/ios/utils/ImageData.mm

@@ -0,0 +1,4 @@
+#import "ImageData.h"
+
+@implementation ImageData
+@end

package/ios/utils/LayoutManagerExtension.mm

@@ -3,6 +3,7 @@
 #import "EnrichedTextInputView.h"
 #import "StyleHeaders.h"
 #import "ParagraphsUtils.h"
+#import "ColorExtension.h"
 
 @implementation NSLayoutManager (LayoutManagerExtension)
 
@@ -52,11 +53,122 @@ static void const *kInputKey = &kInputKey;
   EnrichedTextInputView *typedInput = (EnrichedTextInputView *)self.input;
   if(typedInput == nullptr) { return; }
   
+  NSRange inputRange = NSMakeRange(0, typedInput->textView.textStorage.length);
+    
+  [self drawBlockQuotes:typedInput origin:origin inputRange:inputRange];
+  [self drawLists:typedInput origin:origin inputRange:inputRange];
+  [self drawCodeBlocks:typedInput origin:origin inputRange:inputRange];
+}
+
+- (void)drawCodeBlocks:(EnrichedTextInputView *)typedInput origin:(CGPoint)origin inputRange:(NSRange)inputRange
+{
+  CodeBlockStyle *codeBlockStyle = typedInput->stylesDict[@([CodeBlockStyle getStyleType])];
+  if(codeBlockStyle == nullptr) { return; }
+  
+  NSArray<StylePair *> *allCodeBlocks = [codeBlockStyle findAllOccurences:inputRange];
+  NSArray<StylePair *> *mergedCodeBlocks = [self mergeContiguousStylePairs:allCodeBlocks];
+  UIColor *bgColor = [[typedInput->config codeBlockBgColor] colorWithAlphaIfNotTransparent:0.4];
+  CGFloat radius = [typedInput->config codeBlockBorderRadius];
+  [bgColor setFill];
+  
+  for (StylePair *pair in mergedCodeBlocks) {
+    NSRange blockCharacterRange = [pair.rangeValue rangeValue];
+    if (blockCharacterRange.length == 0) continue;
+    
+    NSArray *paragraphs = [ParagraphsUtils getSeparateParagraphsRangesIn:typedInput->textView range:blockCharacterRange];
+    if (paragraphs.count == 0) continue;
+    
+    NSRange firstParagraphRange = [((NSValue *)[paragraphs firstObject]) rangeValue];
+    NSRange lastParagraphRange = [((NSValue *)[paragraphs lastObject]) rangeValue];
+
+    for (NSValue *paragraphValue in paragraphs) {
+      NSRange paragraphCharacterRange = [paragraphValue rangeValue];
+      
+      BOOL isFirstParagraph = NSEqualRanges(paragraphCharacterRange, firstParagraphRange);
+      BOOL isLastParagraph = NSEqualRanges(paragraphCharacterRange, lastParagraphRange);
+      
+      NSRange paragraphGlyphRange = [self glyphRangeForCharacterRange:paragraphCharacterRange actualCharacterRange:NULL];
+      
+      __block BOOL isFirstLineOfParagraph = YES;
+      
+      [self enumerateLineFragmentsForGlyphRange:paragraphGlyphRange
+                                     usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer * _Nonnull textContainer, NSRange glyphRange, BOOL * _Nonnull stop) {
+        
+        CGRect lineBgRect = rect;
+        lineBgRect.origin.x = origin.x;
+        lineBgRect.origin.y += origin.y;
+        lineBgRect.size.width = textContainer.size.width;
+        
+        UIRectCorner cornersForThisLine = 0;
+        
+        if (isFirstParagraph && isFirstLineOfParagraph) {
+          cornersForThisLine = UIRectCornerTopLeft | UIRectCornerTopRight;
+        }
+        
+        BOOL isLastLineOfParagraph = (NSMaxRange(glyphRange) >= NSMaxRange(paragraphGlyphRange));
+        
+        if (isLastParagraph && isLastLineOfParagraph) {
+          cornersForThisLine = cornersForThisLine | UIRectCornerBottomLeft | UIRectCornerBottomRight;
+        }
+        
+        UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:lineBgRect
+                                                   byRoundingCorners:cornersForThisLine
+                                                         cornerRadii:CGSizeMake(radius, radius)];
+        [path fill];
+        
+        isFirstLineOfParagraph = NO;
+      }];
+    }
+  }
+}
+
+- (NSArray<StylePair *> *)mergeContiguousStylePairs:(NSArray<StylePair *> *)pairs
+{
+  if (pairs.count == 0) {
+    return @[];
+  }
+  
+  NSMutableArray<StylePair *> *mergedPairs = [[NSMutableArray alloc] init];
+  StylePair *currentPair = pairs[0];
+  NSRange currentRange = [currentPair.rangeValue rangeValue];
+  for (NSUInteger i = 1; i < pairs.count; i++) {
+    StylePair *nextPair = pairs[i];
+    NSRange nextRange = [nextPair.rangeValue rangeValue];
+
+    // The Gap Check:
+    // NSMaxRange(currentRange) is where the current block ends.
+    // nextRange.location is where the next block starts.
+    if (NSMaxRange(currentRange) == nextRange.location) {
+      // They touch perfectly (no gap). Merge them.
+      currentRange.length += nextRange.length;
+    } else {
+      // There is a gap (indices don't match).
+      // 1. Save the finished block.
+      StylePair *mergedPair = [[StylePair alloc] init];
+      mergedPair.rangeValue = [NSValue valueWithRange:currentRange];
+      mergedPair.styleValue = currentPair.styleValue;
+      [mergedPairs addObject:mergedPair];
+      
+      // 2. Start a brand new block.
+      currentPair = nextPair;
+      currentRange = nextRange;
+    }
+  }
+
+  // Add the final block
+  StylePair *lastPair = [[StylePair alloc] init];
+  lastPair.rangeValue = [NSValue valueWithRange:currentRange];
+  lastPair.styleValue = currentPair.styleValue;
+  [mergedPairs addObject:lastPair];
+
+  return mergedPairs;
+}
+
+- (void)drawBlockQuotes:(EnrichedTextInputView *)typedInput origin:(CGPoint)origin inputRange:(NSRange)inputRange
+{
   BlockQuoteStyle *bqStyle = typedInput->stylesDict[@([BlockQuoteStyle getStyleType])];
   if(bqStyle == nullptr) { return; }
   
-  NSRange inputRange = NSMakeRange(0, typedInput->textView.textStorage.length);
-  
   // it isn't the most performant but we have to check for all the blockquotes each time and redraw them
   NSArray *allBlockquotes = [bqStyle findAllOccurences:inputRange];
   
@@ -78,7 +190,10 @@ static void const *kInputKey = &kInputKey;
       }
     ];
   }
-    
+}
+
+- (void)drawLists:(EnrichedTextInputView *)typedInput origin:(CGPoint)origin inputRange:(NSRange)inputRange
+{
   UnorderedListStyle *ulStyle = typedInput->stylesDict[@([UnorderedListStyle getStyleType])];
   OrderedListStyle *olStyle = typedInput->stylesDict[@([OrderedListStyle getStyleType])];
   if(ulStyle == nullptr || olStyle == nullptr) { return; }

package/ios/utils/OccurenceUtils.h

@@ -40,4 +40,8 @@
   withInput:(EnrichedTextInputView* _Nonnull)input
   inRange:(NSRange)range
   withCondition:(BOOL (NS_NOESCAPE ^_Nonnull)(id _Nullable value, NSRange range))condition;
++ (NSArray *_Nonnull)getRangesWithout
+  :(NSArray<NSNumber *> *_Nonnull)types
+  withInput:(EnrichedTextInputView* _Nonnull)input
+  inRange:(NSRange)range;
 @end

package/ios/utils/OccurenceUtils.mm

@@ -152,4 +152,51 @@
   return occurences;
 }
 
++ (NSArray *_Nonnull)getRangesWithout
+  :(NSArray<NSNumber *> *_Nonnull)types
+  withInput:(EnrichedTextInputView* _Nonnull)input
+  inRange:(NSRange)range
+{
+  NSMutableArray<id> *activeStyleObjects = [[NSMutableArray alloc] init];
+  for(NSNumber *type in types) {
+    id<BaseStyleProtocol> styleClass = input->stylesDict[type];
+    [activeStyleObjects addObject:styleClass];
+  }
+  
+  if (activeStyleObjects.count == 0) {
+    return @[[NSValue valueWithRange:range]];
+  }
+  
+  NSMutableArray<NSValue *> *newRanges = [[NSMutableArray alloc] init];
+  NSUInteger lastRangeLocation = range.location;
+  NSUInteger endLocation = range.location + range.length;
+
+  for (NSUInteger i = range.location; i < endLocation; i++) {
+    NSRange currentRange = NSMakeRange(i, 1);
+    BOOL forbiddenStyleFound = NO;
+
+    for (id style in activeStyleObjects) {
+      if ([style detectStyle:currentRange]) {
+        forbiddenStyleFound = YES;
+        break;
+      }
+    }
+
+    if (forbiddenStyleFound) {
+      if (i > lastRangeLocation) {
+          NSRange cleanRange = NSMakeRange(lastRangeLocation, i - lastRangeLocation);
+          [newRanges addObject:[NSValue valueWithRange:cleanRange]];
+      }
+      lastRangeLocation = i + 1;
+    }
+  }
+
+  if (lastRangeLocation < endLocation) {
+    NSRange remainingRange = NSMakeRange(lastRangeLocation, endLocation - lastRangeLocation);
+    [newRanges addObject:[NSValue valueWithRange:remainingRange]];
+  }
+
+  return newRanges;
+}
+
 @end

package/ios/utils/ParagraphAttributesUtils.h

@@ -3,4 +3,5 @@
 
 @interface ParagraphAttributesUtils : NSObject
 + (BOOL)handleBackspaceInRange:(NSRange)range replacementText:(NSString *)text input:(id)input;
++ (BOOL)handleNewlineBackspaceInRange:(NSRange)range replacementText:(NSString *)text input:(id)input;
 @end

package/ios/utils/ParagraphAttributesUtils.mm

@@ -8,12 +8,13 @@
 
 // if the user backspaces the last character in a line, the iOS applies typing attributes from the previous line
 // in the case of some paragraph styles it works especially bad when a list point just appears
-// hence the solution - reset typing attributes
+// this method handles that case differently with or without present paragraph styles
 + (BOOL)handleBackspaceInRange:(NSRange)range replacementText:(NSString *)text input:(id)input {
   EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
   UnorderedListStyle *ulStyle = typedInput->stylesDict[@([UnorderedListStyle getStyleType])];
   OrderedListStyle *olStyle = typedInput->stylesDict[@([OrderedListStyle getStyleType])];
   BlockQuoteStyle *bqStyle = typedInput->stylesDict[@([BlockQuoteStyle getStyleType])];
+  CodeBlockStyle *cbStyle = typedInput->stylesDict[@([CodeBlockStyle getStyleType])];
   
   if(typedInput == nullptr) {
     return NO;
@@ -34,29 +35,25 @@
   
   NSRange nonNewlineRange = [(NSValue *)paragraphs.firstObject rangeValue];
   
-  // if the backspace removes the whole content of a paragraph (possibly more but has to start where the paragraph starts), we remove the typing attributes
+  // the backspace removes the whole content of a paragraph (possibly more but has to start where the paragraph starts)
   if(range.location == nonNewlineRange.location && range.length >= nonNewlineRange.length) {
-    // for lists and quotes we want to remove the characters but keep attribtues so that a zero width space appears here
-    // so we do the removing manually and reapply attributes
-    if([ulStyle detectStyle:nonNewlineRange]) {
-      [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:typedInput withSelection:YES];
-      [ulStyle addAttributes:NSMakeRange(range.location, 0)];
-      return YES;
-    }
-    if([olStyle detectStyle:nonNewlineRange]) {
-      [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:typedInput withSelection:YES];
-      [olStyle addAttributes:NSMakeRange(range.location, 0)];
-      return YES;
-    }
-    if([bqStyle detectStyle:nonNewlineRange]) {
-      [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:typedInput withSelection:YES];
-      [bqStyle addAttributes:NSMakeRange(range.location, 0)];
-      return YES;
+    
+    // for lists, quotes and codeblocks present we do the following:
+    // - manually do the removing
+    // - reset typing attribtues so that the previous line styles don't get applied
+    // - reapply the paragraph style that was present so that a zero width space appears here
+    NSArray *handledStyles = @[ulStyle, olStyle, bqStyle, cbStyle];
+    for(id<BaseStyleProtocol> style in handledStyles) {
+      if([style detectStyle:nonNewlineRange]) {
+        [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:typedInput withSelection:YES];
+        typedInput->textView.typingAttributes = typedInput->defaultTypingAttributes;
+        [style addAttributes:NSMakeRange(range.location, 0)];
+        return YES;
+      }
     }
   
-    // do the replacement manually
+    // otherwise (no paragraph styles present), we just do the replacement manually and reset typing attribtues
     [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:typedInput withSelection:YES];
-    // reset typing attribtues
     typedInput->textView.typingAttributes = typedInput->defaultTypingAttributes;
     return YES;
   }
@@ -64,4 +61,74 @@
   return NO;
 }
 
+/**
+ * Handles the specific case of backspacing a newline character, which results in merging two paragraphs.
+ *
+ * THE PROBLEM:
+ * When merging a bottom paragraph (Source) into a top paragraph (Destination), the bottom paragraph
+ * normally brings all its attributes with it. If the top paragraph is a restrictive style (like a CodeBlock),
+ * and the bottom paragraph contains a conflicting style (like an H1 Header), a standard merge would
+ * create an invalid state (e.g., a CodeBlock that is also a Header).
+ *
+ * THE SOLUTION:
+ * 1. Identifies the dominant style of the paragraph ABOVE the deleted newline (`leftParagraphStyle`).
+ * 2. Checks the paragraph BELOW the newline (`rightRange`) for any styles that conflict with or are blocked by the top style.
+ * 3. Explicitly removes those forbidden styles from the bottom paragraph *before* the merge occurs.
+ * 4. Performs the merge (deletes the newline).
+ *
+ * @return YES if the newline backspace was handled and sanitized; NO otherwise.
+ */
++ (BOOL)handleNewlineBackspaceInRange:(NSRange)range replacementText:(NSString *)text input:(id)input {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if(typedInput == nullptr) {
+    return NO;
+  }
+  
+  if(text.length == 0 && range.length == 1 &&
+     [[NSCharacterSet newlineCharacterSet] characterIsMember:[typedInput->textView.textStorage.string characterAtIndex:range.location]]) {
+    NSRange leftRange = [typedInput->textView.textStorage.string paragraphRangeForRange:range];
+    
+    id<BaseStyleProtocol> leftParagraphStyle = nullptr;
+    for (NSNumber *key in typedInput->stylesDict) {
+      id<BaseStyleProtocol> style = typedInput->stylesDict[key];
+      if([[style class] isParagraphStyle] && [style detectStyle:leftRange]) {
+        leftParagraphStyle = style;
+      }
+    }
+    
+    if(leftParagraphStyle == nullptr) {
+      return NO;
+    }
+    
+    // index out of bounds
+    if(range.location + 1 >= typedInput->textView.textStorage.string.length) {
+      return NO;
+    }
+    
+    NSRange rightRange = [typedInput->textView.textStorage.string paragraphRangeForRange:NSMakeRange(range.location + 1, 1)];
+    
+    StyleType type = [[leftParagraphStyle class] getStyleType];
+    
+    NSArray *conflictingStyles = [typedInput getPresentStyleTypesFrom:typedInput->conflictingStyles[@(type)] range:rightRange];
+    NSArray *blockingStyles = [typedInput getPresentStyleTypesFrom:typedInput->blockingStyles[@(type)] range:rightRange];
+    NSArray *allToBeRemoved = [conflictingStyles arrayByAddingObjectsFromArray:blockingStyles];
+    
+    for(NSNumber *style in allToBeRemoved) {
+      id<BaseStyleProtocol> styleClass = typedInput->stylesDict[style];
+      
+      // for ranges, we need to remove each occurence
+      NSArray<StylePair *> *allOccurences = [styleClass findAllOccurences:rightRange];
+      
+      for(StylePair* pair in allOccurences) {
+        [styleClass removeAttributes: [pair.rangeValue rangeValue]];
+      }
+    }
+    
+    [TextInsertionUtils replaceText:text at:range additionalAttributes:nullptr input:typedInput withSelection:YES];
+    return YES;
+  }
+  
+  return NO;
+}
+
 @end

package/ios/utils/StringExtension.h

@@ -6,7 +6,7 @@
 - (std::string)toCppString;
 + (NSString *)fromCppString:(std::string)string;
 + (NSString *)stringByEscapingHtml:(NSString *)html;
-+ (NSString *)stringByUnescapingHtml:(NSString *)html;
++ (NSDictionary *)getEscapedCharactersInfoFrom:(NSString *)text;
 @end
 
 @interface NSMutableString (StringExtension)