@fendent/react-native-enriched 0.5.2-fork.1

package/ios/utils/ParagraphAttributesUtils.mm

@@ -0,0 +1,257 @@
+#import "ParagraphAttributesUtils.h"
+#import "EnrichedTextInputView.h"
+#import "RangeUtils.h"
+#import "StyleHeaders.h"
+#import "TextInsertionUtils.h"
+
+@implementation ParagraphAttributesUtils
+
+// 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 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;
+  if (typedInput == nullptr) {
+    return NO;
+  }
+
+  // we make sure it was a backspace (text with 0 length) and it deleted
+  // something (range longer than 0)
+  if (text.length > 0 || range.length == 0) {
+    return NO;
+  }
+
+  // find a non-newline range of the paragraph
+  NSRange paragraphRange =
+      [typedInput->textView.textStorage.string paragraphRangeForRange:range];
+
+  NSArray *paragraphs = [RangeUtils getNonNewlineRangesIn:typedInput->textView
+                                                    range:paragraphRange];
+  if (paragraphs.count == 0) {
+    return NO;
+  }
+
+  NSRange nonNewlineRange = [(NSValue *)paragraphs.firstObject rangeValue];
+  CheckboxListStyle *cbLStyle =
+      typedInput->stylesDict[@([CheckboxListStyle getType])];
+
+  // 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 styles that need ZWS (lists, quotes, etc.) we do the following:
+    // - manually do the removing
+    // - reset typing attributes 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
+    for (NSNumber *type in typedInput->stylesDict) {
+      StyleBase *style = typedInput->stylesDict[type];
+      if ([style needsZWS] && [style detect:nonNewlineRange]) {
+        BOOL isCurrentlyChecked = [cbLStyle getCheckboxStateAt:range.location];
+        [TextInsertionUtils replaceText:text
+                                     at:range
+                   additionalAttributes:nullptr
+                                  input:typedInput
+                          withSelection:YES];
+        typedInput->textView.typingAttributes =
+            typedInput->defaultTypingAttributes;
+
+        if (style == cbLStyle) {
+          [cbLStyle addWithChecked:isCurrentlyChecked
+                             range:NSMakeRange(range.location, 0)
+                        withTyping:YES
+                    withDirtyRange:YES];
+        } else {
+          [style add:NSMakeRange(range.location, 0)
+                  withTyping:YES
+              withDirtyRange:YES];
+        }
+        return YES;
+      }
+    }
+
+    // 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];
+    typedInput->textView.typingAttributes = typedInput->defaultTypingAttributes;
+    return YES;
+  }
+
+  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)handleParagraphStylesMergeOnBackspace:(NSRange)range
+                              replacementText:(NSString *)text
+                                        input:(id)input {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return NO;
+  }
+
+  // Must be a backspace.
+  if (text.length > 0) {
+    return NO;
+  }
+
+  // Backspace must have removed a newline character.
+  NSString *removedString =
+      [typedInput->textView.textStorage.string substringWithRange:range];
+  if ([removedString
+          rangeOfCharacterFromSet:[NSCharacterSet newlineCharacterSet]]
+          .location == NSNotFound) {
+    return NO;
+  }
+
+  NSRange leftRange = [typedInput->textView.textStorage.string
+      paragraphRangeForRange:NSMakeRange(range.location, 0)];
+
+  StyleBase *leftParagraphStyle = nullptr;
+  for (NSNumber *key in typedInput->stylesDict) {
+    StyleBase *style = typedInput->stylesDict[key];
+    if ([style isParagraph] && [style detect:leftRange]) {
+      leftParagraphStyle = style;
+    }
+  }
+
+  if (leftParagraphStyle == nullptr) {
+    return NO;
+  }
+
+  // index out of bounds
+  NSUInteger rightRangeStart = range.location + range.length;
+  if (rightRangeStart >= typedInput->textView.textStorage.string.length) {
+    return NO;
+  }
+
+  NSRange rightRange = [typedInput->textView.textStorage.string
+      paragraphRangeForRange:NSMakeRange(rightRangeStart, 1)];
+
+  StyleType type = [[leftParagraphStyle class] getType];
+
+  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) {
+    StyleBase *styleToRemove = typedInput->stylesDict[style];
+
+    // for ranges, we need to remove each occurence
+    NSArray<StylePair *> *allOccurences = [styleToRemove all:rightRange];
+
+    for (StylePair *pair in allOccurences) {
+      [styleToRemove remove:[pair.rangeValue rangeValue] withDirtyRange:YES];
+    }
+  }
+
+  [TextInsertionUtils replaceText:text
+                               at:range
+             additionalAttributes:nullptr
+                            input:typedInput
+                    withSelection:YES];
+  return YES;
+}
+
+/**
+ * Resets typing attributes to defaults when the cursor lands on an empty line
+ * after a deletion.
+ *
+ * This override is necessary because `UITextView` automatically inherits
+ * attributes from the preceding newline. This prevents scenarios where a
+ * restrictive style (like CodeBlock) "leaks" into the next empty paragraph.
+ */
++ (BOOL)handleResetTypingAttributesOnBackspace:(NSRange)range
+                               replacementText:(NSString *)text
+                                         input:(id)input {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return NO;
+  }
+
+  NSString *storageString = typedInput->textView.textStorage.string;
+
+  if (text.length > 0 || range.location >= storageString.length) {
+    return NO;
+  }
+
+  unichar firstCharToDelete = [storageString characterAtIndex:range.location];
+  if (![[NSCharacterSet newlineCharacterSet]
+          characterIsMember:firstCharToDelete]) {
+    return NO;
+  }
+
+  NSRange leftParagraphRange =
+      [storageString paragraphRangeForRange:NSMakeRange(range.location, 0)];
+  BOOL isLeftLineEmpty = [self isParagraphEmpty:leftParagraphRange
+                                       inString:storageString];
+
+  BOOL isRightLineEmpty = YES;
+  NSUInteger rightRangeStart = range.location + range.length;
+
+  if (rightRangeStart < storageString.length) {
+    NSRange rightParagraphRange =
+        [storageString paragraphRangeForRange:NSMakeRange(rightRangeStart, 0)];
+    isRightLineEmpty = [self isParagraphEmpty:rightParagraphRange
+                                     inString:storageString];
+  }
+
+  if (isLeftLineEmpty && isRightLineEmpty) {
+    [TextInsertionUtils replaceText:text
+                                 at:range
+               additionalAttributes:nullptr
+                              input:typedInput
+                      withSelection:YES];
+
+    typedInput->textView.typingAttributes = typedInput->defaultTypingAttributes;
+    return YES;
+  }
+
+  return NO;
+}
+
++ (BOOL)isParagraphEmpty:(NSRange)range inString:(NSString *)string {
+  if (range.length == 0)
+    return YES;
+
+  NSString *paragraphText = [string substringWithRange:range];
+  NSString *trimmed = [paragraphText
+      stringByTrimmingCharactersInSet:[NSCharacterSet newlineCharacterSet]];
+  return trimmed.length == 0;
+}
+
+@end

package/ios/utils/RangeUtils.h

@@ -0,0 +1,12 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface RangeUtils : NSObject
++ (NSArray *)getSeparateParagraphsRangesIn:(UITextView *)textView
+                                     range:(NSRange)range;
++ (NSArray *)getNonNewlineRangesIn:(UITextView *)textView range:(NSRange)range;
++ (NSArray *)connectAndDedupeRanges:(NSArray *)ranges;
++ (NSArray *)shiftRanges:(NSArray *)ranges
+         withEditedRange:(NSRange)editedRange
+          changeInLength:(NSInteger)delta;
+@end

package/ios/utils/RangeUtils.mm

@@ -0,0 +1,183 @@
+#import "RangeUtils.h"
+
+@implementation RangeUtils
+
++ (NSArray *)getSeparateParagraphsRangesIn:(UITextView *)textView
+                                     range:(NSRange)range {
+  // just in case, get full paragraphs range
+  NSRange fullRange =
+      [textView.textStorage.string paragraphRangeForRange:range];
+
+  // we are in an empty paragraph
+  if (fullRange.length == 0) {
+    return @[ [NSValue valueWithRange:fullRange] ];
+  }
+
+  NSMutableArray *results = [[NSMutableArray alloc] init];
+
+  NSInteger lastStart = fullRange.location;
+  for (int i = int(fullRange.location);
+       i < fullRange.location + fullRange.length; i++) {
+    unichar currentChar = [textView.textStorage.string characterAtIndex:i];
+    if ([[NSCharacterSet newlineCharacterSet] characterIsMember:currentChar]) {
+      NSRange paragraphRange = [textView.textStorage.string
+          paragraphRangeForRange:NSMakeRange(lastStart, i - lastStart)];
+      [results addObject:[NSValue valueWithRange:paragraphRange]];
+      lastStart = i + 1;
+    }
+  }
+
+  if (lastStart < fullRange.location + fullRange.length) {
+    NSRange paragraphRange = [textView.textStorage.string
+        paragraphRangeForRange:NSMakeRange(lastStart, fullRange.location +
+                                                          fullRange.length -
+                                                          lastStart)];
+    [results addObject:[NSValue valueWithRange:paragraphRange]];
+  }
+
+  return results;
+}
+
++ (NSArray *)getNonNewlineRangesIn:(UITextView *)textView range:(NSRange)range {
+  NSMutableArray *nonNewlineRanges = [[NSMutableArray alloc] init];
+  int lastRangeLocation = int(range.location);
+
+  for (int i = int(range.location); i < range.location + range.length; i++) {
+    unichar currentChar = [textView.textStorage.string characterAtIndex:i];
+    if ([[NSCharacterSet newlineCharacterSet] characterIsMember:currentChar]) {
+      if (i - lastRangeLocation > 0) {
+        [nonNewlineRanges
+            addObject:[NSValue
+                          valueWithRange:NSMakeRange(lastRangeLocation,
+                                                     i - lastRangeLocation)]];
+      }
+      lastRangeLocation = i + 1;
+    }
+  }
+  if (lastRangeLocation < range.location + range.length) {
+    [nonNewlineRanges
+        addObject:[NSValue
+                      valueWithRange:NSMakeRange(lastRangeLocation,
+                                                 range.location + range.length -
+                                                     lastRangeLocation)]];
+  }
+
+  return nonNewlineRanges;
+}
+
+// Condenses an array of NSRange to make sure the overlapping ones are connected
+// + sorted based on NSRange.location
++ (NSArray *)connectAndDedupeRanges:(NSArray *)ranges {
+  if (ranges.count == 0) {
+    return @[];
+  }
+
+  // We sort primarily by location. If locations match, shorter length goes
+  // first
+  NSArray<NSValue *> *sortedRanges =
+      [ranges sortedArrayUsingComparator:^NSComparisonResult(NSValue *obj1,
+                                                             NSValue *obj2) {
+        NSRange range1 = obj1.rangeValue;
+        NSRange range2 = obj2.rangeValue;
+
+        if (range1.location < range2.location)
+          return NSOrderedAscending;
+        if (range1.location > range2.location)
+          return NSOrderedDescending;
+
+        if (range1.length < range2.length)
+          return NSOrderedAscending;
+        if (range1.length > range2.length)
+          return NSOrderedDescending;
+
+        return NSOrderedSame;
+      }];
+
+  NSMutableArray<NSValue *> *mergedRanges = [[NSMutableArray alloc] init];
+
+  // We work by comparing each two ranges.
+  // If we connected some ranges, the newly created one is still compared with
+  // the next ranges from the sorted list.
+  NSRange currentRange = sortedRanges[0].rangeValue;
+
+  for (NSUInteger i = 1; i < sortedRanges.count; i++) {
+    NSRange nextRange = sortedRanges[i].rangeValue;
+
+    // Calculate the end points
+    NSUInteger currentMax = currentRange.location + currentRange.length;
+    NSUInteger nextMax = nextRange.location + nextRange.length;
+
+    // If next range starts before (or exactly when) the current one ends.
+    if (nextRange.location <= currentMax) {
+      // Merge them; the new end is the maximum of the two ends
+      NSUInteger newMax = MAX(currentMax, nextMax);
+      currentRange.length = newMax - currentRange.location;
+    } else {
+      // No overlap; push the current range and start a new one
+      [mergedRanges addObject:[NSValue valueWithRange:currentRange]];
+      currentRange = nextRange;
+    }
+  }
+
+  // Add the final range
+  [mergedRanges addObject:[NSValue valueWithRange:currentRange]];
+
+  return [mergedRanges copy];
+}
+
+// Updates a list of NSRanges based on a text change, so that they are still
+// pointing to the same characters. editedRange is the post-change range of the
+// edited fragment. delta tells what is the length change of the edited
+// fragment. While the ranges outside of the change are being just shifted, the
+// ones intersecting with it are just merging with the change.
++ (NSArray *)shiftRanges:(NSArray *)ranges
+         withEditedRange:(NSRange)editedRange
+          changeInLength:(NSInteger)delta {
+  NSMutableArray *result = [[NSMutableArray alloc] init];
+
+  // Calculate what the changed range was like before being edited
+  NSUInteger oldEditLength = editedRange.length - delta;
+  NSUInteger oldEditEnd = editedRange.location + oldEditLength;
+
+  NSUInteger newEditEnd = editedRange.location + editedRange.length;
+
+  for (NSValue *value in ranges) {
+    NSRange range = [value rangeValue];
+    NSUInteger rangeEnd = range.location + range.length;
+
+    if (rangeEnd <= editedRange.location) {
+      // Range was strictly before the old edit range.
+      // Do nothing.
+      [result addObject:value];
+    } else if (range.location >= oldEditEnd) {
+      // Range was strictly after the old edit range.
+      // Shift it by the delta.
+      [result
+          addObject:[NSValue valueWithRange:NSMakeRange(range.location + delta,
+                                                        range.length)]];
+    } else {
+      // Range overlaps the old edit range in some way.
+      // Our best bet is to merge it with the edit range.
+
+      NSUInteger newStart = MIN(range.location, editedRange.location);
+
+      NSUInteger newEnd;
+      if (rangeEnd <= oldEditEnd) {
+        // The range was inside the editedRange before.
+        // So we use the newer editRange as the end here.
+        newEnd = newEditEnd;
+      } else {
+        // The range sticked outside of the editedRange before.
+        // It is safe to shift its end and use it.
+        newEnd = rangeEnd + delta;
+      }
+
+      NSRange adjustedRange = NSMakeRange(newStart, newEnd - newStart);
+      [result addObject:[NSValue valueWithRange:adjustedRange]];
+    }
+  }
+
+  return result;
+}
+
+@end

package/ios/utils/TextBlockTapGestureRecognizer.h

@@ -0,0 +1,17 @@
+typedef NS_ENUM(NSInteger, TextBlockTapKind) {
+  TextBlockTapKindNone = 0,
+  TextBlockTapKindCheckbox,
+};
+
+@class EnrichedTextInputView;
+
+@interface TextBlockTapGestureRecognizer : UITapGestureRecognizer
+- (instancetype _Nonnull)initWithInput:(id _Nonnull)input
+                                action:(SEL _Nonnull)action;
+
+@property(nonatomic, weak) EnrichedTextInputView *input;
+
+@property(nonatomic, assign, readonly) TextBlockTapKind tapKind;
+@property(nonatomic, assign, readonly) NSInteger characterIndex;
+
+@end

package/ios/utils/TextBlockTapGestureRecognizer.mm

@@ -0,0 +1,56 @@
+#import "TextBlockTapGestureRecognizer.h"
+#import "CheckboxHitTestUtils.h"
+#import "EnrichedTextInputView.h"
+
+@implementation TextBlockTapGestureRecognizer {
+  TextBlockTapKind _tapKind;
+  NSInteger _characterIndex;
+}
+
+- (instancetype)initWithInput:(id)input action:(SEL)action {
+  self = [super initWithTarget:input action:action];
+  _input = input;
+
+  self.cancelsTouchesInView = YES;
+  self.delaysTouchesBegan = YES;
+  self.delaysTouchesEnded = YES;
+
+  for (UIGestureRecognizer *gr in _input->textView.gestureRecognizers) {
+    [gr requireGestureRecognizerToFail:self];
+  }
+
+  return self;
+}
+
+- (TextBlockTapKind)tapKind {
+  return _tapKind;
+}
+
+- (NSInteger)characterIndex {
+  return _characterIndex;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  _tapKind = TextBlockTapKindNone;
+  _characterIndex = NSNotFound;
+
+  if (!self.input) {
+    self.state = UIGestureRecognizerStateFailed;
+    return;
+  }
+
+  UITouch *touch = touches.anyObject;
+  CGPoint point = [touch locationInView:self.input->textView];
+  NSInteger checkboxIndex =
+      [CheckboxHitTestUtils hitTestCheckboxAtPoint:point inInput:self.input];
+
+  if (checkboxIndex >= 0) {
+    _tapKind = TextBlockTapKindCheckbox;
+    _characterIndex = checkboxIndex;
+    [super touchesBegan:touches withEvent:event];
+    return;
+  }
+  self.state = UIGestureRecognizerStateFailed;
+}
+
+@end

package/ios/utils/TextInsertionUtils.h

@@ -0,0 +1,17 @@
+#import <UIKit/UIKit.h>
+
+@interface TextInsertionUtils : NSObject
++ (void)insertText:(NSString *)text
+                      at:(NSInteger)index
+    additionalAttributes:
+        (NSDictionary<NSAttributedStringKey, id> *)additionalAttrs
+                   input:(id)input
+           withSelection:(BOOL)withSelection;
++ (void)replaceText:(NSString *)text
+                      at:(NSRange)range
+    additionalAttributes:
+        (NSDictionary<NSAttributedStringKey, id> *)additionalAttrs
+                   input:(id)input
+           withSelection:(BOOL)withSelection;
+;
+@end

package/ios/utils/TextInsertionUtils.mm

@@ -0,0 +1,64 @@
+#import "TextInsertionUtils.h"
+#import "EnrichedTextInputView.h"
+#import "UIView+React.h"
+
+@implementation TextInsertionUtils
++ (void)insertText:(NSString *)text
+                      at:(NSInteger)index
+    additionalAttributes:
+        (NSDictionary<NSAttributedStringKey, id> *)additionalAttrs
+                   input:(id)input
+           withSelection:(BOOL)withSelection {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  UITextView *textView = typedInput->textView;
+
+  NSMutableDictionary<NSAttributedStringKey, id> *copiedAttrs =
+      [textView.typingAttributes mutableCopy];
+  if (additionalAttrs != nullptr) {
+    [copiedAttrs addEntriesFromDictionary:additionalAttrs];
+  }
+
+  NSAttributedString *newAttrStr =
+      [[NSAttributedString alloc] initWithString:text attributes:copiedAttrs];
+  [textView.textStorage insertAttributedString:newAttrStr atIndex:index];
+
+  if (withSelection) {
+    if (![textView isFirstResponder]) {
+      [textView reactFocus];
+    }
+    textView.selectedRange = NSMakeRange(index + text.length, 0);
+  }
+}
+
++ (void)replaceText:(NSString *)text
+                      at:(NSRange)range
+    additionalAttributes:
+        (NSDictionary<NSAttributedStringKey, id> *)additionalAttrs
+                   input:(id)input
+           withSelection:(BOOL)withSelection {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  UITextView *textView = typedInput->textView;
+
+  [textView.textStorage replaceCharactersInRange:range withString:text];
+  if (additionalAttrs != nullptr) {
+    [textView.textStorage
+        addAttributes:additionalAttrs
+                range:NSMakeRange(range.location, [text length])];
+  }
+
+  if (withSelection) {
+    if (![textView isFirstResponder]) {
+      [textView reactFocus];
+    }
+    textView.selectedRange = NSMakeRange(range.location + text.length, 0);
+  }
+}
+@end

package/ios/utils/WordsUtils.h

@@ -0,0 +1,7 @@
+#import <UIKit/UIKit.h>
+
+@interface WordsUtils : NSObject
++ (NSArray<NSDictionary *> *)getAffectedWordsFromText:(NSString *)text
+                                    modificationRange:(NSRange)range;
++ (NSDictionary *)getCurrentWord:(NSString *)text range:(NSRange)range;
+@end