react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/ios/input/ENRMAutoLinkDetector.mm

@@ -0,0 +1,211 @@
+#import "ENRMAutoLinkDetector.h"
+
+#import "ENRMFormattingRange.h"
+#import "InputStylePropsUtils.h"
+
+static NSAttributedStringKey const ENRMAutomaticLinkAttributeName = @"ENRMAutomaticLink";
+
+@implementation ENRMAutoLinkDetector {
+  __weak NSTextStorage *_textStorage;
+  __weak ENRMFormattingStore *_formattingStore;
+  __weak ENRMInputFormatterStyle *_style;
+  ENRMLinkRegexConfig *_regexConfig;
+}
+
+- (instancetype)initWithTextStorage:(NSTextStorage *)textStorage
+                    formattingStore:(ENRMFormattingStore *)store
+                              style:(ENRMInputFormatterStyle *)style
+{
+  self = [super init];
+  if (self) {
+    _textStorage = textStorage;
+    _formattingStore = store;
+    _style = style;
+  }
+  return self;
+}
+
+- (void)setRegexConfig:(ENRMLinkRegexConfig *)config
+{
+  _regexConfig = config;
+}
+
+#pragma mark - ENRMTextDetector
+
+- (void)processWord:(ENRMWordResult *)wordResult
+{
+  NSString *detectedUrl = [self detectNewLinkAtRange:wordResult.range inText:wordResult.word];
+  if (detectedUrl != nil && _onLinkDetected != nil) {
+    _onLinkDetected(wordResult.word, detectedUrl, wordResult.range);
+  }
+}
+
+- (void)refreshStyling
+{
+  NSTextStorage *textStorage = _textStorage;
+  if (textStorage == nil || textStorage.length == 0) {
+    return;
+  }
+
+  [textStorage beginEditing];
+  [textStorage enumerateAttribute:ENRMAutomaticLinkAttributeName
+                          inRange:NSMakeRange(0, textStorage.length)
+                          options:0
+                       usingBlock:^(id value, NSRange range, BOOL *stop) {
+                         if (value != nil) {
+                           [self applyVisualStylingToRange:range];
+                         }
+                       }];
+  [textStorage endEditing];
+}
+
+- (NSArray<ENRMFormattingRange *> *)transientFormattingRanges
+{
+  NSTextStorage *textStorage = _textStorage;
+  if (textStorage == nil || textStorage.length == 0) {
+    return @[];
+  }
+
+  NSMutableArray<ENRMFormattingRange *> *ranges = [NSMutableArray array];
+  [textStorage enumerateAttribute:ENRMAutomaticLinkAttributeName
+                          inRange:NSMakeRange(0, textStorage.length)
+                          options:0
+                       usingBlock:^(id value, NSRange range, BOOL *stop) {
+                         if (value != nil && [value isKindOfClass:[NSString class]]) {
+                           ENRMFormattingRange *fmtRange = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
+                                                                                        range:range
+                                                                                          url:value];
+                           [ranges addObject:fmtRange];
+                         }
+                       }];
+  return ranges;
+}
+
+- (void)clearAutoLinkInRange:(NSRange)range
+{
+  NSTextStorage *textStorage = _textStorage;
+  if (textStorage == nil || NSMaxRange(range) > textStorage.length) {
+    return;
+  }
+  [textStorage removeAttribute:ENRMAutomaticLinkAttributeName range:range];
+}
+
+#pragma mark - Link matching
+
+- (nullable NSString *)detectNewLinkAtRange:(NSRange)wordRange inText:(NSString *)word
+{
+  if (_regexConfig != nil && _regexConfig.isDisabled) {
+    return nil;
+  }
+
+  NSTextStorage *textStorage = _textStorage;
+  if (textStorage == nil) {
+    return nil;
+  }
+
+  if (NSMaxRange(wordRange) > textStorage.length) {
+    return nil;
+  }
+
+  ENRMFormattingStore *store = _formattingStore;
+  if (store != nil) {
+    ENRMFormattingRange *manualLink = [store rangeOfType:ENRMInputStyleTypeLink containingPosition:wordRange.location];
+    if (manualLink != nil) {
+      return nil;
+    }
+  }
+
+  NSString *matchedUrl = [self tryMatchWord:word];
+
+  if (matchedUrl != nil) {
+    NSRange effectiveRange;
+    id existing = [textStorage attribute:ENRMAutomaticLinkAttributeName
+                                 atIndex:wordRange.location
+                          effectiveRange:&effectiveRange];
+    BOOL alreadyApplied = [matchedUrl isEqual:existing] && NSEqualRanges(effectiveRange, wordRange);
+
+    if (!alreadyApplied) {
+      [textStorage beginEditing];
+      [textStorage addAttribute:ENRMAutomaticLinkAttributeName value:matchedUrl range:wordRange];
+      [self applyVisualStylingToRange:wordRange];
+      [textStorage endEditing];
+    }
+  } else {
+    id existing = [textStorage attribute:ENRMAutomaticLinkAttributeName atIndex:wordRange.location effectiveRange:nil];
+    if (existing != nil) {
+      [textStorage beginEditing];
+      [textStorage removeAttribute:ENRMAutomaticLinkAttributeName range:wordRange];
+      [textStorage endEditing];
+    }
+  }
+
+  return matchedUrl;
+}
+
+- (nullable NSString *)tryMatchWord:(NSString *)word
+{
+  if (word.length == 0) {
+    return nil;
+  }
+
+  NSRange matchRange = NSMakeRange(0, word.length);
+
+  if (_regexConfig != nil && !_regexConfig.isDefault && _regexConfig.parsedRegex != nil) {
+    if ([_regexConfig.parsedRegex numberOfMatchesInString:word options:0 range:matchRange]) {
+      return [ENRMAutoLinkDetector normalizeUrl:word];
+    }
+    return nil;
+  }
+
+  if ([[ENRMAutoLinkDetector defaultRegex] numberOfMatchesInString:word options:0 range:matchRange]) {
+    return [ENRMAutoLinkDetector normalizeUrl:word];
+  }
+
+  return nil;
+}
+
++ (NSString *)normalizeUrl:(NSString *)url
+{
+  if ([url hasPrefix:@"http://"] || [url hasPrefix:@"https://"]) {
+    return url;
+  }
+  return [@"https://" stringByAppendingString:url];
+}
+
+#pragma mark - Visual styling
+
+- (void)applyVisualStylingToRange:(NSRange)range
+{
+  NSTextStorage *textStorage = _textStorage;
+  ENRMInputFormatterStyle *style = _style;
+  if (textStorage == nil || style == nil) {
+    return;
+  }
+
+  [textStorage addAttribute:NSForegroundColorAttributeName value:style.linkColor range:range];
+  if (style.linkUnderline) {
+    [textStorage addAttribute:NSUnderlineStyleAttributeName value:@(NSUnderlineStyleSingle) range:range];
+  }
+}
+
+#pragma mark - Default regex
+
++ (NSRegularExpression *)defaultRegex
+{
+  static NSRegularExpression *regex;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSError *error = nil;
+    regex = [NSRegularExpression
+        regularExpressionWithPattern:
+            @"(?:https?://[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-z]{2,6}\\b[-a-zA-Z0-9@:%_\\+.~#?&//=]*"
+            @"|www\\.[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-z]{2,6}\\b[-a-zA-Z0-9@:%_\\+.~#?&//=]*"
+            @"|[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-z]{2,6}\\b[-a-zA-Z0-9@:%_\\+.~#?&//=]*)"
+                             options:NSRegularExpressionCaseInsensitive
+                               error:&error];
+    NSCAssert(regex != nil, @"ENRMAutoLinkDetector: failed to compile default regex: %@", error);
+  });
+  return regex;
+}
+
+@end

package/ios/input/ENRMDetectorPipeline.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#import "ENRMFormattingRange.h"
+#import "ENRMTextDetector.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Coordinates a set of ENRMTextDetector instances. The input view calls
+/// this pipeline instead of individual detectors.
+@interface ENRMDetectorPipeline : NSObject
+
+- (void)addDetector:(id<ENRMTextDetector>)detector;
+
+/// Run all detectors over the affected words for a given modification range.
+- (void)processTextChange:(NSString *)text modificationRange:(NSRange)range;
+
+/// Re-apply visual styling for all detectors after the formatter
+/// resets base attributes. Call right after applyFormattingRanges.
+- (void)refreshAllStyling;
+
+/// Collect transient formatting ranges from every detector,
+/// suitable for merging with FormattingStore ranges before serialization.
+- (NSArray<ENRMFormattingRange *> *)allTransientFormattingRanges;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMDetectorPipeline.mm

@@ -0,0 +1,53 @@
+#import "ENRMDetectorPipeline.h"
+
+#import "ENRMWordsUtils.h"
+
+@implementation ENRMDetectorPipeline {
+  NSMutableArray<id<ENRMTextDetector>> *_detectors;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    _detectors = [NSMutableArray array];
+  }
+  return self;
+}
+
+- (void)addDetector:(id<ENRMTextDetector>)detector
+{
+  [_detectors addObject:detector];
+}
+
+- (void)processTextChange:(NSString *)text modificationRange:(NSRange)range
+{
+  NSArray<ENRMWordResult *> *words = [ENRMWordsUtils getAffectedWordsFromText:text modificationRange:range];
+
+  for (ENRMWordResult *wordResult in words) {
+    for (id<ENRMTextDetector> detector in _detectors) {
+      [detector processWord:wordResult];
+    }
+  }
+}
+
+- (void)refreshAllStyling
+{
+  for (id<ENRMTextDetector> detector in _detectors) {
+    [detector refreshStyling];
+  }
+}
+
+- (NSArray<ENRMFormattingRange *> *)allTransientFormattingRanges
+{
+  NSMutableArray<ENRMFormattingRange *> *all = [NSMutableArray array];
+  for (id<ENRMTextDetector> detector in _detectors) {
+    NSArray<ENRMFormattingRange *> *ranges = [detector transientFormattingRanges];
+    if (ranges.count > 0) {
+      [all addObjectsFromArray:ranges];
+    }
+  }
+  return all;
+}
+
+@end

package/ios/input/ENRMFormattingRange.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#import "ENRMInputStyledRange.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMFormattingRange : NSObject <NSCopying>
+
+@property (nonatomic, assign) ENRMInputStyleType type;
+@property (nonatomic, assign) NSRange range;
+@property (nonatomic, strong, nullable) NSString *url;
+
++ (instancetype)rangeWithType:(ENRMInputStyleType)type range:(NSRange)range;
++ (instancetype)rangeWithType:(ENRMInputStyleType)type range:(NSRange)range url:(nullable NSString *)url;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMFormattingRange.mm

@@ -0,0 +1,28 @@
+#import "ENRMFormattingRange.h"
+
+@implementation ENRMFormattingRange
+
++ (instancetype)rangeWithType:(ENRMInputStyleType)type range:(NSRange)range
+{
+  return [self rangeWithType:type range:range url:nil];
+}
+
++ (instancetype)rangeWithType:(ENRMInputStyleType)type range:(NSRange)range url:(nullable NSString *)url
+{
+  ENRMFormattingRange *formattingRange = [[ENRMFormattingRange alloc] init];
+  formattingRange.type = type;
+  formattingRange.range = range;
+  formattingRange.url = url;
+  return formattingRange;
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  ENRMFormattingRange *copy = [[ENRMFormattingRange allocWithZone:zone] init];
+  copy.type = _type;
+  copy.range = _range;
+  copy.url = [_url copy];
+  return copy;
+}
+
+@end

package/ios/input/ENRMFormattingStore.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#import "ENRMFormattingRange.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMFormattingStore : NSObject
+
+@property (nonatomic, readonly) NSArray<ENRMFormattingRange *> *allRanges;
+
+- (void)setRanges:(NSArray<ENRMFormattingRange *> *)ranges;
+- (void)clearAll;
+
+- (nullable ENRMFormattingRange *)rangeOfType:(ENRMInputStyleType)type containingPosition:(NSUInteger)position;
+- (BOOL)isStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position;
+- (BOOL)isStyleActive:(ENRMInputStyleType)type inRange:(NSRange)range;
+- (NSArray<ENRMFormattingRange *> *)rangesOfType:(ENRMInputStyleType)type;
+
+- (void)addRange:(ENRMFormattingRange *)range;
+- (void)removeType:(ENRMInputStyleType)type inRange:(NSRange)range;
+- (void)removeRange:(ENRMFormattingRange *)range;
+
+- (void)adjustForEditAtLocation:(NSUInteger)location
+                  deletedLength:(NSUInteger)deletedLength
+                 insertedLength:(NSUInteger)insertedLength;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMFormattingStore.mm

@@ -0,0 +1,278 @@
+#import "ENRMFormattingStore.h"
+
+static NSUInteger sortedInsertionIndex(NSArray<ENRMFormattingRange *> *ranges, NSUInteger location)
+{
+  NSUInteger index = 0;
+  for (ENRMFormattingRange *existing in ranges) {
+    if (existing.range.location > location)
+      break;
+    index++;
+  }
+  return index;
+}
+
+static void removeIndexesInReverse(NSMutableArray *array, NSMutableIndexSet *indexes)
+{
+  [indexes enumerateIndexesWithOptions:NSEnumerationReverse
+                            usingBlock:^(NSUInteger idx, BOOL *stop) { [array removeObjectAtIndex:idx]; }];
+}
+
+typedef NS_ENUM(NSInteger, EditOverlap) {
+  EditOverlapBeforeEdit,
+  EditOverlapAfterEdit,
+  EditOverlapFullyDeleted,
+  EditOverlapDeletedInside,
+  EditOverlapClippedEnd,
+  EditOverlapClippedStart,
+};
+
+static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, NSUInteger editLocation,
+                                   NSUInteger deleteEnd)
+{
+  if (rangeEnd <= editLocation)
+    return EditOverlapBeforeEdit;
+  if (rangeStart >= deleteEnd)
+    return EditOverlapAfterEdit;
+  if (rangeStart >= editLocation && rangeEnd <= deleteEnd)
+    return EditOverlapFullyDeleted;
+  if (rangeStart < editLocation && rangeEnd > deleteEnd)
+    return EditOverlapDeletedInside;
+  if (rangeStart < editLocation && rangeEnd <= deleteEnd)
+    return EditOverlapClippedEnd;
+  return EditOverlapClippedStart;
+}
+
+@implementation ENRMFormattingStore {
+  NSMutableArray<ENRMFormattingRange *> *_ranges;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _ranges = [NSMutableArray array];
+  }
+  return self;
+}
+
+- (NSArray<ENRMFormattingRange *> *)allRanges
+{
+  return [_ranges copy];
+}
+
+- (NSArray<ENRMFormattingRange *> *)rangesOfType:(ENRMInputStyleType)type
+{
+  NSMutableArray<ENRMFormattingRange *> *result = [NSMutableArray array];
+  for (ENRMFormattingRange *formattingRange in _ranges) {
+    if (formattingRange.type == type) {
+      [result addObject:formattingRange];
+    }
+  }
+  return result;
+}
+
+- (void)setRanges:(NSArray<ENRMFormattingRange *> *)ranges
+{
+  _ranges =
+      [[ranges sortedArrayUsingComparator:^NSComparisonResult(ENRMFormattingRange *first, ENRMFormattingRange *second) {
+        if (first.range.location < second.range.location)
+          return NSOrderedAscending;
+        if (first.range.location > second.range.location)
+          return NSOrderedDescending;
+        return NSOrderedSame;
+      }] mutableCopy];
+}
+
+- (void)clearAll
+{
+  [_ranges removeAllObjects];
+}
+
+- (nullable ENRMFormattingRange *)rangeOfType:(ENRMInputStyleType)type containingPosition:(NSUInteger)position
+{
+  for (ENRMFormattingRange *formattingRange in _ranges) {
+    if (formattingRange.type != type)
+      continue;
+    if (position >= formattingRange.range.location && position < NSMaxRange(formattingRange.range)) {
+      return formattingRange;
+    }
+  }
+  return nil;
+}
+
+- (BOOL)isStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position
+{
+  return [self rangeOfType:type containingPosition:position] != nil;
+}
+
+- (BOOL)isStyleActive:(ENRMInputStyleType)type inRange:(NSRange)range
+{
+  for (ENRMFormattingRange *formattingRange in _ranges) {
+    if (formattingRange.type == type && NSIntersectionRange(formattingRange.range, range).length > 0) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (void)addRange:(ENRMFormattingRange *)newRange
+{
+  NSMutableIndexSet *mergeIndexes = [NSMutableIndexSet indexSet];
+  NSUInteger mergedStart = newRange.range.location;
+  NSUInteger mergedEnd = NSMaxRange(newRange.range);
+
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMFormattingRange *existing = _ranges[idx];
+    if (existing.type != newRange.type)
+      continue;
+
+    NSUInteger existingEnd = NSMaxRange(existing.range);
+    if (existing.range.location <= mergedEnd && existingEnd >= mergedStart) {
+      mergedStart = MIN(mergedStart, existing.range.location);
+      mergedEnd = MAX(mergedEnd, existingEnd);
+      [mergeIndexes addIndex:idx];
+    }
+  }
+
+  removeIndexesInReverse(_ranges, mergeIndexes);
+
+  ENRMFormattingRange *merged = [ENRMFormattingRange rangeWithType:newRange.type
+                                                             range:NSMakeRange(mergedStart, mergedEnd - mergedStart)
+                                                               url:newRange.url];
+
+  NSUInteger insertAt = sortedInsertionIndex(_ranges, merged.range.location);
+  [_ranges insertObject:merged atIndex:insertAt];
+}
+
+- (void)removeType:(ENRMInputStyleType)type inRange:(NSRange)removeRange
+{
+  NSMutableArray<ENRMFormattingRange *> *remainders = [NSMutableArray array];
+  NSMutableIndexSet *indexesToRemove = [NSMutableIndexSet indexSet];
+
+  NSUInteger removeStart = removeRange.location;
+  NSUInteger removeEnd = NSMaxRange(removeRange);
+
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMFormattingRange *existing = _ranges[idx];
+    if (existing.type != type)
+      continue;
+
+    NSUInteger existingStart = existing.range.location;
+    NSUInteger existingEnd = NSMaxRange(existing.range);
+
+    if (existingEnd <= removeStart || existingStart >= removeEnd) {
+      continue;
+    }
+
+    [indexesToRemove addIndex:idx];
+
+    if (existingStart < removeStart) {
+      [remainders addObject:[ENRMFormattingRange rangeWithType:type
+                                                         range:NSMakeRange(existingStart, removeStart - existingStart)
+                                                           url:existing.url]];
+    }
+    if (existingEnd > removeEnd) {
+      [remainders addObject:[ENRMFormattingRange rangeWithType:type
+                                                         range:NSMakeRange(removeEnd, existingEnd - removeEnd)
+                                                           url:existing.url]];
+    }
+  }
+
+  removeIndexesInReverse(_ranges, indexesToRemove);
+
+  // Remainders are fragments of a just-removed range and cannot overlap others.
+  for (ENRMFormattingRange *remainder in remainders) {
+    NSUInteger insertAt = sortedInsertionIndex(_ranges, remainder.range.location);
+    [_ranges insertObject:remainder atIndex:insertAt];
+  }
+}
+
+- (void)removeRange:(ENRMFormattingRange *)range
+{
+  [_ranges removeObject:range];
+}
+
+- (void)adjustForEditAtLocation:(NSUInteger)editLocation
+                  deletedLength:(NSUInteger)deletedLength
+                 insertedLength:(NSUInteger)insertedLength
+{
+  if (deletedLength == 0 && insertedLength == 0)
+    return;
+
+  NSUInteger deleteEnd = editLocation + deletedLength;
+  NSMutableIndexSet *indexesToRemove = [NSMutableIndexSet indexSet];
+
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMFormattingRange *formattingRange = _ranges[idx];
+    NSUInteger rangeStart = formattingRange.range.location;
+    NSUInteger rangeEnd = NSMaxRange(formattingRange.range);
+
+    if (deletedLength > 0) {
+      EditOverlap overlap = classifyOverlap(rangeStart, rangeEnd, editLocation, deleteEnd);
+
+      switch (overlap) {
+        case EditOverlapBeforeEdit:
+          break;
+
+        case EditOverlapAfterEdit:
+          formattingRange.range =
+              NSMakeRange(rangeStart - deletedLength + insertedLength, formattingRange.range.length);
+          break;
+
+        case EditOverlapFullyDeleted:
+          [indexesToRemove addIndex:idx];
+          break;
+
+        case EditOverlapDeletedInside: {
+          NSUInteger newLength = formattingRange.range.length - deletedLength + insertedLength;
+          formattingRange.range = NSMakeRange(rangeStart, newLength);
+          break;
+        }
+
+        case EditOverlapClippedEnd: {
+          NSUInteger newEnd = editLocation + insertedLength;
+          NSUInteger newLength = newEnd > rangeStart ? newEnd - rangeStart : 0;
+          formattingRange.range = NSMakeRange(rangeStart, newLength);
+          if (newLength == 0) {
+            [indexesToRemove addIndex:idx];
+          }
+          break;
+        }
+
+        case EditOverlapClippedStart: {
+          NSUInteger charsClipped = deleteEnd - rangeStart;
+          NSUInteger newStart = editLocation + insertedLength;
+          NSUInteger newLength = formattingRange.range.length - charsClipped;
+          formattingRange.range = NSMakeRange(newStart, newLength);
+          if (newLength == 0) {
+            [indexesToRemove addIndex:idx];
+          }
+          break;
+        }
+      }
+    } else {
+      if (rangeStart >= editLocation) {
+        // Insertion at or before the range start: shift right.
+        // _pendingStyles handles whether the inserted text inherits the style.
+        formattingRange.range = NSMakeRange(rangeStart + insertedLength, formattingRange.range.length);
+      } else if (editLocation < rangeEnd) {
+        formattingRange.range = NSMakeRange(rangeStart, formattingRange.range.length + insertedLength);
+      }
+      // Typing at rangeEnd does not expand — pending styles control
+      // whether new text at the boundary inherits the style.
+    }
+  }
+
+  removeIndexesInReverse(_ranges, indexesToRemove);
+
+  NSMutableIndexSet *emptyIndexes = [NSMutableIndexSet indexSet];
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    if (_ranges[idx].range.length == 0) {
+      [emptyIndexes addIndex:idx];
+    }
+  }
+  if (emptyIndexes.count > 0) {
+    removeIndexesInReverse(_ranges, emptyIndexes);
+  }
+}
+
+@end